Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/no_op.h

@@ -0,0 +1,41 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_NO_OP_H_
+#define TENSORFLOW_CC_OPS_NO_OP_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup no_op No Op
+/// @{
+
+/// Does nothing. Only useful as a placeholder for control edges.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class NoOp {
+ public:
+  NoOp(const ::tensorflow::Scope& scope);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_NO_OP_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/no_op_internal.h

@@ -0,0 +1,28 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_NO_OP_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_NO_OP_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup no_op_internal No Op Internal
+/// @{
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_NO_OP_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/parsing_ops.h

@@ -0,0 +1,1285 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_PARSING_OPS_H_
+#define TENSORFLOW_CC_OPS_PARSING_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup parsing_ops Parsing Ops
+/// @{
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `OutputList`: Each tensor will have the same shape as records.
+class DecodeCSV {
+ public:
+  /// Optional attribute setters for DecodeCSV
+  struct Attrs {
+    /// char delimiter to separate fields in a record.
+    ///
+    /// Defaults to ","
+    TF_MUST_USE_RESULT Attrs FieldDelim(StringPiece x) {
+      Attrs ret = *this;
+      ret.field_delim_ = x;
+      return ret;
+    }
+
+    /// If false, treats double quotation marks as regular
+    /// characters inside of the string fields (ignoring RFC 4180, Section 2,
+    /// Bullet 5).
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseQuoteDelim(bool x) {
+      Attrs ret = *this;
+      ret.use_quote_delim_ = x;
+      return ret;
+    }
+
+    /// Additional string to recognize as NA/NaN.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs NaValue(StringPiece x) {
+      Attrs ret = *this;
+      ret.na_value_ = x;
+      return ret;
+    }
+
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs SelectCols(const gtl::ArraySlice<int>& x) {
+      Attrs ret = *this;
+      ret.select_cols_ = x;
+      return ret;
+    }
+
+    StringPiece field_delim_ = ",";
+    bool use_quote_delim_ = true;
+    StringPiece na_value_ = "";
+    gtl::ArraySlice<int> select_cols_ = {};
+  };
+  DecodeCSV(const ::tensorflow::Scope& scope, ::tensorflow::Input records,
+          ::tensorflow::InputList record_defaults);
+  DecodeCSV(const ::tensorflow::Scope& scope, ::tensorflow::Input records,
+          ::tensorflow::InputList record_defaults, const DecodeCSV::Attrs&
+          attrs);
+  ::tensorflow::Output operator[](size_t index) const { return output[index]; }
+
+
+  static Attrs FieldDelim(StringPiece x) {
+    return Attrs().FieldDelim(x);
+  }
+  static Attrs UseQuoteDelim(bool x) {
+    return Attrs().UseQuoteDelim(x);
+  }
+  static Attrs NaValue(StringPiece x) {
+    return Attrs().NaValue(x);
+  }
+  static Attrs SelectCols(const gtl::ArraySlice<int>& x) {
+    return Attrs().SelectCols(x);
+  }
+
+  Operation operation;
+  ::tensorflow::OutputList output;
+};
+
+/// 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`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * bytes: A Tensor of string which is compressed.
+///
+/// Optional attributes (see `Attrs`):
+/// * compression_type: A scalar containing either (i) the empty string (no
+/// compression), (ii) "ZLIB", or (iii) "GZIP".
+///
+/// Returns:
+/// * `Output`: A Tensor with the same shape as input `bytes`, uncompressed
+/// from bytes.
+class DecodeCompressed {
+ public:
+  /// Optional attribute setters for DecodeCompressed
+  struct Attrs {
+    /// A scalar containing either (i) the empty string (no
+    /// compression), (ii) "ZLIB", or (iii) "GZIP".
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs CompressionType(StringPiece x) {
+      Attrs ret = *this;
+      ret.compression_type_ = x;
+      return ret;
+    }
+
+    StringPiece compression_type_ = "";
+  };
+  DecodeCompressed(const ::tensorflow::Scope& scope, ::tensorflow::Input bytes);
+  DecodeCompressed(const ::tensorflow::Scope& scope, ::tensorflow::Input bytes,
+                 const DecodeCompressed::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs CompressionType(StringPiece x) {
+    return Attrs().CompressionType(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Convert JSON-encoded Example records to binary protocol buffer strings.
+///
+///
+/// Note: This is **not** a general purpose JSON parsing op.
+///
+/// This op converts JSON-serialized
+/// `tf.train.Example` (created with `json_format.MessageToJson`, following the
+/// [standard JSON mapping](https://developers.google.com/protocol-buffers/docs/proto3#json))
+/// to a binary-serialized `tf.train.Example` (equivalent to
+/// `Example.SerializeToString()`) suitable for conversion to tensors with
+/// `tf.io.parse_example`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * json_examples: Each string is a JSON object serialized according to the JSON
+/// mapping of the Example proto.
+///
+/// Returns:
+/// * `Output`: Each string is a binary Example protocol buffer corresponding
+/// to the respective element of `json_examples`.
+class DecodeJSONExample {
+ public:
+  DecodeJSONExample(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  json_examples);
+  operator ::tensorflow::Output() const { return binary_examples; }
+  operator ::tensorflow::Input() const { return binary_examples; }
+  ::tensorflow::Node* node() const { return binary_examples.node(); }
+
+  Operation operation;
+  ::tensorflow::Output binary_examples;
+};
+
+/// Reinterpret the bytes of a string as a vector of numbers.
+///
+/// Args:
+/// * scope: A Scope object
+/// * input_bytes: Tensor of string to be decoded.
+/// * fixed_length: Length in bytes for each element of the decoded output. Must be a multiple
+/// of the size of the output type.
+///
+/// Optional attributes (see `Attrs`):
+/// * little_endian: Whether the input `input_bytes` is in little-endian order. Ignored for
+/// `out_type` values that are stored in a single byte, like `uint8`
+///
+/// Returns:
+/// * `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`.
+class DecodePaddedRaw {
+ public:
+  /// Optional attribute setters for DecodePaddedRaw
+  struct Attrs {
+    /// Whether the input `input_bytes` is in little-endian order. Ignored for
+    /// `out_type` values that are stored in a single byte, like `uint8`
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs LittleEndian(bool x) {
+      Attrs ret = *this;
+      ret.little_endian_ = x;
+      return ret;
+    }
+
+    bool little_endian_ = true;
+  };
+  DecodePaddedRaw(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_bytes, ::tensorflow::Input fixed_length, DataType
+                out_type);
+  DecodePaddedRaw(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_bytes, ::tensorflow::Input fixed_length, DataType
+                out_type, const DecodePaddedRaw::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs LittleEndian(bool x) {
+    return Attrs().LittleEndian(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Reinterpret the bytes of a string as a vector of numbers.
+///
+/// Args:
+/// * scope: A Scope object
+/// * bytes: All the elements must have the same length.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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`.
+///
+/// Returns:
+/// * `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`.
+class DecodeRaw {
+ public:
+  /// Optional attribute setters for DecodeRaw
+  struct Attrs {
+    /// Whether the input `bytes` are in little-endian order.
+    /// Ignored for `out_type` values that are stored in a single byte like
+    /// `uint8`.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs LittleEndian(bool x) {
+      Attrs ret = *this;
+      ret.little_endian_ = x;
+      return ret;
+    }
+
+    bool little_endian_ = true;
+  };
+  DecodeRaw(const ::tensorflow::Scope& scope, ::tensorflow::Input bytes, DataType
+          out_type);
+  DecodeRaw(const ::tensorflow::Scope& scope, ::tensorflow::Input bytes, DataType
+          out_type, const DecodeRaw::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs LittleEndian(bool x) {
+    return Attrs().LittleEndian(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Transforms a vector of brain.Example protos (as strings) into typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+/// * 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.
+///
+/// Returns:
+/// * `OutputList` sparse_indices
+/// * `OutputList` sparse_values
+/// * `OutputList` sparse_shapes
+/// * `OutputList` dense_values
+class ParseExample {
+ public:
+  ParseExample(const ::tensorflow::Scope& scope, ::tensorflow::Input serialized,
+             ::tensorflow::Input names, ::tensorflow::InputList sparse_keys,
+             ::tensorflow::InputList dense_keys, ::tensorflow::InputList
+             dense_defaults, const DataTypeSlice& sparse_types, const
+             gtl::ArraySlice<PartialTensorShape>& dense_shapes);
+
+  Operation operation;
+  ::tensorflow::OutputList sparse_indices;
+  ::tensorflow::OutputList sparse_values;
+  ::tensorflow::OutputList sparse_shapes;
+  ::tensorflow::OutputList dense_values;
+};
+
+/// Transforms a vector of tf.Example protos (as strings) into typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * serialized: A scalar or vector containing binary serialized Example protos.
+/// * names: A tensor containing the names of the serialized protos.
+/// Corresponds 1:1 with the `serialized` tensor.
+/// 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 tensor must have the same shape as "serialized".
+/// * sparse_keys: Vector of strings.
+/// The keys expected in the Examples' features associated with sparse values.
+/// * dense_keys: Vector of strings.
+/// The keys expected in the Examples' features associated with dense values.
+/// * ragged_keys: Vector of strings.
+/// The keys expected in the Examples' features associated with ragged values.
+/// * dense_defaults: A list of Tensors (some may be empty).  Corresponds 1:1 with `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.
+/// * num_sparse: The number of sparse keys.
+/// * sparse_types: A list of `num_sparse` 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).
+/// * ragged_value_types: A list of `num_ragged` types; the data types of data in each Feature
+/// given in ragged_keys (where `num_ragged = sparse_keys.size()`).
+/// Currently the ParseExample supports DT_FLOAT (FloatList),
+/// DT_INT64 (Int64List), and DT_STRING (BytesList).
+/// * ragged_split_types: A list of `num_ragged` types; the data types of row_splits in each Feature
+/// given in ragged_keys (where `num_ragged = sparse_keys.size()`).
+/// May be DT_INT32 or DT_INT64.
+/// * dense_shapes: A list of `num_dense` shapes; the shapes of data in each Feature
+/// given in dense_keys (where `num_dense = dense_keys.size()`).
+/// 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.
+///
+/// Returns:
+/// * `OutputList` sparse_indices
+/// * `OutputList` sparse_values
+/// * `OutputList` sparse_shapes
+/// * `OutputList` dense_values
+/// * `OutputList` ragged_values
+/// * `OutputList` ragged_row_splits
+class ParseExampleV2 {
+ public:
+  ParseExampleV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
+               serialized, ::tensorflow::Input names, ::tensorflow::Input
+               sparse_keys, ::tensorflow::Input dense_keys, ::tensorflow::Input
+               ragged_keys, ::tensorflow::InputList dense_defaults, int64
+               num_sparse, const DataTypeSlice& sparse_types, const
+               DataTypeSlice& ragged_value_types, const DataTypeSlice&
+               ragged_split_types, const gtl::ArraySlice<PartialTensorShape>&
+               dense_shapes);
+
+  Operation operation;
+  ::tensorflow::OutputList sparse_indices;
+  ::tensorflow::OutputList sparse_values;
+  ::tensorflow::OutputList sparse_shapes;
+  ::tensorflow::OutputList dense_values;
+  ::tensorflow::OutputList ragged_values;
+  ::tensorflow::OutputList ragged_row_splits;
+};
+
+/// Transforms a vector of brain.SequenceExample protos (as strings) into typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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].
+/// * 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.
+///
+/// Optional attributes (see `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().
+///
+/// Returns:
+/// * `OutputList` context_sparse_indices
+/// * `OutputList` context_sparse_values
+/// * `OutputList` context_sparse_shapes
+/// * `OutputList` context_dense_values
+/// * `OutputList` feature_list_sparse_indices
+/// * `OutputList` feature_list_sparse_values
+/// * `OutputList` feature_list_sparse_shapes
+/// * `OutputList` feature_list_dense_values
+/// * `OutputList` feature_list_dense_lengths
+class ParseSequenceExample {
+ public:
+  /// Optional attribute setters for ParseSequenceExample
+  struct Attrs {
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NcontextSparse(int64 x) {
+      Attrs ret = *this;
+      ret.Ncontext_sparse_ = x;
+      return ret;
+    }
+
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NcontextDense(int64 x) {
+      Attrs ret = *this;
+      ret.Ncontext_dense_ = x;
+      return ret;
+    }
+
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NfeatureListSparse(int64 x) {
+      Attrs ret = *this;
+      ret.Nfeature_list_sparse_ = x;
+      return ret;
+    }
+
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NfeatureListDense(int64 x) {
+      Attrs ret = *this;
+      ret.Nfeature_list_dense_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.context_sparse_types_ = x;
+      return ret;
+    }
+
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_types_ = x;
+      return ret;
+    }
+
+    /// 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].
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.context_dense_shapes_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_sparse_types_ = x;
+      return ret;
+    }
+
+    /// 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().
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_shapes_ = x;
+      return ret;
+    }
+
+    int64 Ncontext_sparse_ = 0;
+    int64 Ncontext_dense_ = 0;
+    int64 Nfeature_list_sparse_ = 0;
+    int64 Nfeature_list_dense_ = 0;
+    DataTypeSlice context_sparse_types_ = {};
+    DataTypeSlice feature_list_dense_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> context_dense_shapes_ = {};
+    DataTypeSlice feature_list_sparse_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> feature_list_dense_shapes_ = {};
+  };
+  ParseSequenceExample(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                     serialized, ::tensorflow::Input debug_name,
+                     ::tensorflow::InputList context_dense_defaults, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_dense_missing_assumed_empty, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     context_sparse_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     context_dense_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_sparse_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_dense_keys);
+  ParseSequenceExample(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                     serialized, ::tensorflow::Input debug_name,
+                     ::tensorflow::InputList context_dense_defaults, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_dense_missing_assumed_empty, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     context_sparse_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     context_dense_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_sparse_keys, const
+                     gtl::ArraySlice<::tensorflow::tstring>&
+                     feature_list_dense_keys, const
+                     ParseSequenceExample::Attrs& attrs);
+
+  static Attrs NcontextSparse(int64 x) {
+    return Attrs().NcontextSparse(x);
+  }
+  static Attrs NcontextDense(int64 x) {
+    return Attrs().NcontextDense(x);
+  }
+  static Attrs NfeatureListSparse(int64 x) {
+    return Attrs().NfeatureListSparse(x);
+  }
+  static Attrs NfeatureListDense(int64 x) {
+    return Attrs().NfeatureListDense(x);
+  }
+  static Attrs ContextSparseTypes(const DataTypeSlice& x) {
+    return Attrs().ContextSparseTypes(x);
+  }
+  static Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListDenseTypes(x);
+  }
+  static Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().ContextDenseShapes(x);
+  }
+  static Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListSparseTypes(x);
+  }
+  static Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().FeatureListDenseShapes(x);
+  }
+
+  Operation operation;
+  ::tensorflow::OutputList context_sparse_indices;
+  ::tensorflow::OutputList context_sparse_values;
+  ::tensorflow::OutputList context_sparse_shapes;
+  ::tensorflow::OutputList context_dense_values;
+  ::tensorflow::OutputList feature_list_sparse_indices;
+  ::tensorflow::OutputList feature_list_sparse_values;
+  ::tensorflow::OutputList feature_list_sparse_shapes;
+  ::tensorflow::OutputList feature_list_dense_values;
+  ::tensorflow::OutputList feature_list_dense_lengths;
+};
+
+/// Transforms a vector of tf.io.SequenceExample protos (as strings) into
+/// typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * serialized: A scalar or vector containing binary serialized SequenceExample protos.
+/// * debug_name: A scalar or 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_sparse_keys: The keys expected in the Examples' features associated with context_sparse
+/// values.
+/// * context_dense_keys: The keys expected in the SequenceExamples' context features associated with
+/// dense values.
+/// * context_ragged_keys: The keys expected in the Examples' features associated with context_ragged
+/// values.
+/// * feature_list_sparse_keys: The keys expected in the FeatureLists associated with sparse values.
+/// * feature_list_dense_keys: The keys expected in the SequenceExamples' feature_lists associated
+/// with lists of dense values.
+/// * feature_list_ragged_keys: The keys expected in the FeatureLists associated with ragged values.
+/// * feature_list_dense_missing_assumed_empty: A vector corresponding 1:1 with feature_list_dense_keys, indicating which
+/// features may be missing from the SequenceExamples.  If the associated
+/// FeatureList is missing, it is treated as empty.
+/// * 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].
+///
+/// Optional attributes (see `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_ragged_value_types: RaggedTensor.value dtypes for the ragged context features.
+/// * context_ragged_split_types: RaggedTensor.row_split dtypes for the ragged context features.
+/// * 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_ragged_value_types: RaggedTensor.value dtypes for the ragged FeatureList features.
+/// * feature_list_ragged_split_types: RaggedTensor.row_split dtypes for the ragged FeatureList features.
+/// * 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().
+///
+/// Returns:
+/// * `OutputList` context_sparse_indices
+/// * `OutputList` context_sparse_values
+/// * `OutputList` context_sparse_shapes
+/// * `OutputList` context_dense_values
+/// * `OutputList` context_ragged_values
+/// * `OutputList` context_ragged_row_splits
+/// * `OutputList` feature_list_sparse_indices
+/// * `OutputList` feature_list_sparse_values
+/// * `OutputList` feature_list_sparse_shapes
+/// * `OutputList` feature_list_dense_values
+/// * `OutputList` feature_list_dense_lengths
+/// * `OutputList` feature_list_ragged_values
+/// * `OutputList` feature_list_ragged_outer_splits
+/// * `OutputList` feature_list_ragged_inner_splits
+class ParseSequenceExampleV2 {
+ public:
+  /// Optional attribute setters for ParseSequenceExampleV2
+  struct Attrs {
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NcontextSparse(int64 x) {
+      Attrs ret = *this;
+      ret.Ncontext_sparse_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.context_sparse_types_ = x;
+      return ret;
+    }
+
+    /// RaggedTensor.value dtypes for the ragged context features.
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextRaggedValueTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.context_ragged_value_types_ = x;
+      return ret;
+    }
+
+    /// RaggedTensor.row_split dtypes for the ragged context features.
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextRaggedSplitTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.context_ragged_split_types_ = x;
+      return ret;
+    }
+
+    /// 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].
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.context_dense_shapes_ = x;
+      return ret;
+    }
+
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NfeatureListSparse(int64 x) {
+      Attrs ret = *this;
+      ret.Nfeature_list_sparse_ = x;
+      return ret;
+    }
+
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs NfeatureListDense(int64 x) {
+      Attrs ret = *this;
+      ret.Nfeature_list_dense_ = x;
+      return ret;
+    }
+
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_types_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_sparse_types_ = x;
+      return ret;
+    }
+
+    /// RaggedTensor.value dtypes for the ragged FeatureList features.
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListRaggedValueTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_ragged_value_types_ = x;
+      return ret;
+    }
+
+    /// RaggedTensor.row_split dtypes for the ragged FeatureList features.
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListRaggedSplitTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_ragged_split_types_ = x;
+      return ret;
+    }
+
+    /// 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().
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_shapes_ = x;
+      return ret;
+    }
+
+    int64 Ncontext_sparse_ = 0;
+    DataTypeSlice context_sparse_types_ = {};
+    DataTypeSlice context_ragged_value_types_ = {};
+    DataTypeSlice context_ragged_split_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> context_dense_shapes_ = {};
+    int64 Nfeature_list_sparse_ = 0;
+    int64 Nfeature_list_dense_ = 0;
+    DataTypeSlice feature_list_dense_types_ = {};
+    DataTypeSlice feature_list_sparse_types_ = {};
+    DataTypeSlice feature_list_ragged_value_types_ = {};
+    DataTypeSlice feature_list_ragged_split_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> feature_list_dense_shapes_ = {};
+  };
+  ParseSequenceExampleV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                       serialized, ::tensorflow::Input debug_name,
+                       ::tensorflow::Input context_sparse_keys,
+                       ::tensorflow::Input context_dense_keys,
+                       ::tensorflow::Input context_ragged_keys,
+                       ::tensorflow::Input feature_list_sparse_keys,
+                       ::tensorflow::Input feature_list_dense_keys,
+                       ::tensorflow::Input feature_list_ragged_keys,
+                       ::tensorflow::Input
+                       feature_list_dense_missing_assumed_empty,
+                       ::tensorflow::InputList context_dense_defaults);
+  ParseSequenceExampleV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                       serialized, ::tensorflow::Input debug_name,
+                       ::tensorflow::Input context_sparse_keys,
+                       ::tensorflow::Input context_dense_keys,
+                       ::tensorflow::Input context_ragged_keys,
+                       ::tensorflow::Input feature_list_sparse_keys,
+                       ::tensorflow::Input feature_list_dense_keys,
+                       ::tensorflow::Input feature_list_ragged_keys,
+                       ::tensorflow::Input
+                       feature_list_dense_missing_assumed_empty,
+                       ::tensorflow::InputList context_dense_defaults, const
+                       ParseSequenceExampleV2::Attrs& attrs);
+
+  static Attrs NcontextSparse(int64 x) {
+    return Attrs().NcontextSparse(x);
+  }
+  static Attrs ContextSparseTypes(const DataTypeSlice& x) {
+    return Attrs().ContextSparseTypes(x);
+  }
+  static Attrs ContextRaggedValueTypes(const DataTypeSlice& x) {
+    return Attrs().ContextRaggedValueTypes(x);
+  }
+  static Attrs ContextRaggedSplitTypes(const DataTypeSlice& x) {
+    return Attrs().ContextRaggedSplitTypes(x);
+  }
+  static Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().ContextDenseShapes(x);
+  }
+  static Attrs NfeatureListSparse(int64 x) {
+    return Attrs().NfeatureListSparse(x);
+  }
+  static Attrs NfeatureListDense(int64 x) {
+    return Attrs().NfeatureListDense(x);
+  }
+  static Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListDenseTypes(x);
+  }
+  static Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListSparseTypes(x);
+  }
+  static Attrs FeatureListRaggedValueTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListRaggedValueTypes(x);
+  }
+  static Attrs FeatureListRaggedSplitTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListRaggedSplitTypes(x);
+  }
+  static Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().FeatureListDenseShapes(x);
+  }
+
+  Operation operation;
+  ::tensorflow::OutputList context_sparse_indices;
+  ::tensorflow::OutputList context_sparse_values;
+  ::tensorflow::OutputList context_sparse_shapes;
+  ::tensorflow::OutputList context_dense_values;
+  ::tensorflow::OutputList context_ragged_values;
+  ::tensorflow::OutputList context_ragged_row_splits;
+  ::tensorflow::OutputList feature_list_sparse_indices;
+  ::tensorflow::OutputList feature_list_sparse_values;
+  ::tensorflow::OutputList feature_list_sparse_shapes;
+  ::tensorflow::OutputList feature_list_dense_values;
+  ::tensorflow::OutputList feature_list_dense_lengths;
+  ::tensorflow::OutputList feature_list_ragged_values;
+  ::tensorflow::OutputList feature_list_ragged_outer_splits;
+  ::tensorflow::OutputList feature_list_ragged_inner_splits;
+};
+
+/// Transforms a tf.Example proto (as a string) into typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+/// * 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).
+/// * 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.
+///
+/// Returns:
+/// * `OutputList` sparse_indices
+/// * `OutputList` sparse_values
+/// * `OutputList` sparse_shapes
+/// * `OutputList` dense_values
+class ParseSingleExample {
+ public:
+  ParseSingleExample(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   serialized, ::tensorflow::InputList dense_defaults, int64
+                   num_sparse, const gtl::ArraySlice<::tensorflow::tstring>&
+                   sparse_keys, const gtl::ArraySlice<::tensorflow::tstring>&
+                   dense_keys, const DataTypeSlice& sparse_types, const
+                   gtl::ArraySlice<PartialTensorShape>& dense_shapes);
+
+  Operation operation;
+  ::tensorflow::OutputList sparse_indices;
+  ::tensorflow::OutputList sparse_values;
+  ::tensorflow::OutputList sparse_shapes;
+  ::tensorflow::OutputList dense_values;
+};
+
+/// Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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().
+///
+/// Returns:
+/// * `OutputList` context_sparse_indices
+/// * `OutputList` context_sparse_values
+/// * `OutputList` context_sparse_shapes
+/// * `OutputList` context_dense_values
+/// * `OutputList` feature_list_sparse_indices
+/// * `OutputList` feature_list_sparse_values
+/// * `OutputList` feature_list_sparse_shapes
+/// * `OutputList` feature_list_dense_values
+class ParseSingleSequenceExample {
+ public:
+  /// Optional attribute setters for ParseSingleSequenceExample
+  struct Attrs {
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.context_sparse_types_ = x;
+      return ret;
+    }
+
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_types_ = x;
+      return ret;
+    }
+
+    /// 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].
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.context_dense_shapes_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+      Attrs ret = *this;
+      ret.feature_list_sparse_types_ = x;
+      return ret;
+    }
+
+    /// 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().
+    ///
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+      Attrs ret = *this;
+      ret.feature_list_dense_shapes_ = x;
+      return ret;
+    }
+
+    DataTypeSlice context_sparse_types_ = {};
+    DataTypeSlice feature_list_dense_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> context_dense_shapes_ = {};
+    DataTypeSlice feature_list_sparse_types_ = {};
+    gtl::ArraySlice<PartialTensorShape> feature_list_dense_shapes_ = {};
+  };
+  ParseSingleSequenceExample(const ::tensorflow::Scope& scope,
+                           ::tensorflow::Input serialized, ::tensorflow::Input
+                           feature_list_dense_missing_assumed_empty,
+                           ::tensorflow::InputList context_sparse_keys,
+                           ::tensorflow::InputList context_dense_keys,
+                           ::tensorflow::InputList feature_list_sparse_keys,
+                           ::tensorflow::InputList feature_list_dense_keys,
+                           ::tensorflow::InputList context_dense_defaults,
+                           ::tensorflow::Input debug_name);
+  ParseSingleSequenceExample(const ::tensorflow::Scope& scope,
+                           ::tensorflow::Input serialized, ::tensorflow::Input
+                           feature_list_dense_missing_assumed_empty,
+                           ::tensorflow::InputList context_sparse_keys,
+                           ::tensorflow::InputList context_dense_keys,
+                           ::tensorflow::InputList feature_list_sparse_keys,
+                           ::tensorflow::InputList feature_list_dense_keys,
+                           ::tensorflow::InputList context_dense_defaults,
+                           ::tensorflow::Input debug_name, const
+                           ParseSingleSequenceExample::Attrs& attrs);
+
+  static Attrs ContextSparseTypes(const DataTypeSlice& x) {
+    return Attrs().ContextSparseTypes(x);
+  }
+  static Attrs FeatureListDenseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListDenseTypes(x);
+  }
+  static Attrs ContextDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().ContextDenseShapes(x);
+  }
+  static Attrs FeatureListSparseTypes(const DataTypeSlice& x) {
+    return Attrs().FeatureListSparseTypes(x);
+  }
+  static Attrs FeatureListDenseShapes(const gtl::ArraySlice<PartialTensorShape>& x) {
+    return Attrs().FeatureListDenseShapes(x);
+  }
+
+  Operation operation;
+  ::tensorflow::OutputList context_sparse_indices;
+  ::tensorflow::OutputList context_sparse_values;
+  ::tensorflow::OutputList context_sparse_shapes;
+  ::tensorflow::OutputList context_dense_values;
+  ::tensorflow::OutputList feature_list_sparse_indices;
+  ::tensorflow::OutputList feature_list_sparse_values;
+  ::tensorflow::OutputList feature_list_sparse_shapes;
+  ::tensorflow::OutputList feature_list_dense_values;
+};
+
+/// Transforms a serialized tensorflow.TensorProto proto into a Tensor.
+///
+/// Args:
+/// * scope: A Scope object
+/// * serialized: A scalar string containing a serialized TensorProto proto.
+/// * 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.
+///
+/// Returns:
+/// * `Output`: A Tensor of type `out_type`.
+class ParseTensor {
+ public:
+  ParseTensor(const ::tensorflow::Scope& scope, ::tensorflow::Input serialized,
+            DataType out_type);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Transforms a Tensor into a serialized TensorProto proto.
+///
+/// Args:
+/// * scope: A Scope object
+/// * tensor: A Tensor of type `T`.
+///
+/// Returns:
+/// * `Output`: A serialized TensorProto proto of the input tensor.
+class SerializeTensor {
+ public:
+  SerializeTensor(const ::tensorflow::Scope& scope, ::tensorflow::Input tensor);
+  operator ::tensorflow::Output() const { return serialized; }
+  operator ::tensorflow::Input() const { return serialized; }
+  ::tensorflow::Node* node() const { return serialized.node(); }
+
+  Operation operation;
+  ::tensorflow::Output serialized;
+};
+
+/// 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.)
+///
+/// Example:
+///
+/// >>> strings = ["5.0", "3.0", "7.0"]
+/// >>> tf.strings.to_number(strings)
+/// <tf.Tensor: shape=(3,), dtype=float32, numpy=array([5., 3., 7.], dtype=float32)>
+///
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Optional attributes (see `Attrs`):
+/// * out_type: The numeric type to interpret each string in `string_tensor` as.
+///
+/// Returns:
+/// * `Output`: A Tensor of the same shape as the input `string_tensor`.
+class StringToNumber {
+ public:
+  /// Optional attribute setters for StringToNumber
+  struct Attrs {
+    /// The numeric type to interpret each string in `string_tensor` as.
+    ///
+    /// Defaults to DT_FLOAT
+    TF_MUST_USE_RESULT Attrs OutType(DataType x) {
+      Attrs ret = *this;
+      ret.out_type_ = x;
+      return ret;
+    }
+
+    DataType out_type_ = DT_FLOAT;
+  };
+  StringToNumber(const ::tensorflow::Scope& scope, ::tensorflow::Input
+               string_tensor);
+  StringToNumber(const ::tensorflow::Scope& scope, ::tensorflow::Input
+               string_tensor, const StringToNumber::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs OutType(DataType x) {
+    return Attrs().OutType(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_PARSING_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/parsing_ops_internal.h

@@ -0,0 +1,28 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_PARSING_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_PARSING_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup parsing_ops_internal Parsing Ops Internal
+/// @{
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_PARSING_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/random_ops.h

@@ -0,0 +1,663 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_RANDOM_OPS_H_
+#define TENSORFLOW_CC_OPS_RANDOM_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup random_ops Random Ops
+/// @{
+
+/// Draws samples from a multinomial distribution.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+/// contains the drawn class labels with range `[0, num_classes)`.
+class Multinomial {
+ public:
+  /// Optional attribute setters for Multinomial
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    /// Defaults to DT_INT64
+    TF_MUST_USE_RESULT Attrs OutputDtype(DataType x) {
+      Attrs ret = *this;
+      ret.output_dtype_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+    DataType output_dtype_ = DT_INT64;
+  };
+  Multinomial(const ::tensorflow::Scope& scope, ::tensorflow::Input logits,
+            ::tensorflow::Input num_samples);
+  Multinomial(const ::tensorflow::Scope& scope, ::tensorflow::Input logits,
+            ::tensorflow::Input num_samples, const Multinomial::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+  static Attrs OutputDtype(DataType x) {
+    return Attrs().OutputDtype(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A matrix of shape num_batches x samples_per_batch, filled with random
+/// truncated normal values using the parameters for each row.
+class ParameterizedTruncatedNormal {
+ public:
+  /// Optional attribute setters for ParameterizedTruncatedNormal
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  ParameterizedTruncatedNormal(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input shape, ::tensorflow::Input
+                             means, ::tensorflow::Input stdevs,
+                             ::tensorflow::Input minvals, ::tensorflow::Input
+                             maxvals);
+  ParameterizedTruncatedNormal(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input shape, ::tensorflow::Input
+                             means, ::tensorflow::Input stdevs,
+                             ::tensorflow::Input minvals, ::tensorflow::Input
+                             maxvals, const
+                             ParameterizedTruncatedNormal::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `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.
+class RandomGamma {
+ public:
+  /// Optional attribute setters for RandomGamma
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  RandomGamma(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+            ::tensorflow::Input alpha);
+  RandomGamma(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+            ::tensorflow::Input alpha, const RandomGamma::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor with shape `shape + shape(rate)`. Each slice
+/// `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+/// `rate[i0, i1, ...iN]`.
+class RandomPoissonV2 {
+ public:
+  /// Optional attribute setters for RandomPoissonV2
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    /// Defaults to DT_INT64
+    TF_MUST_USE_RESULT Attrs Dtype(DataType x) {
+      Attrs ret = *this;
+      ret.dtype_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+    DataType dtype_ = DT_INT64;
+  };
+  RandomPoissonV2(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                ::tensorflow::Input rate);
+  RandomPoissonV2(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                ::tensorflow::Input rate, const RandomPoissonV2::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+  static Attrs Dtype(DataType x) {
+    return Attrs().Dtype(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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]]
+/// ```
+///
+/// Args:
+/// * scope: A Scope object
+/// * value: The tensor to be shuffled.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor of same shape and type as `value`, shuffled along its first
+/// dimension.
+class RandomShuffle {
+ public:
+  /// Optional attribute setters for RandomShuffle
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  RandomShuffle(const ::tensorflow::Scope& scope, ::tensorflow::Input value);
+  RandomShuffle(const ::tensorflow::Scope& scope, ::tensorflow::Input value,
+              const RandomShuffle::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Outputs random values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// Args:
+/// * scope: A Scope object
+/// * shape: The shape of the output tensor.
+/// * dtype: The type of the output.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor of the specified shape filled with random normal values.
+class RandomNormal {
+ public:
+  /// Optional attribute setters for RandomNormal
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  RandomNormal(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+             DataType dtype);
+  RandomNormal(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+             DataType dtype, const RandomNormal::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * shape: The shape of the output tensor.
+/// * dtype: The type of the output.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor of the specified shape filled with uniform random values.
+class RandomUniform {
+ public:
+  /// Optional attribute setters for RandomUniform
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  RandomUniform(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+              DataType dtype);
+  RandomUniform(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+              DataType dtype, const RandomUniform::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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`).
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor of the specified shape filled with uniform random integers.
+class RandomUniformInt {
+ public:
+  /// Optional attribute setters for RandomUniformInt
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  RandomUniformInt(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                 ::tensorflow::Input minval, ::tensorflow::Input maxval);
+  RandomUniformInt(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                 ::tensorflow::Input minval, ::tensorflow::Input maxval, const
+                 RandomUniformInt::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * shape: The shape of the output tensor.
+/// * dtype: The type of the output.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A tensor of the specified shape filled with random truncated normal
+/// values.
+class TruncatedNormal {
+ public:
+  /// Optional attribute setters for TruncatedNormal
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed(int64 x) {
+      Attrs ret = *this;
+      ret.seed_ = x;
+      return ret;
+    }
+
+    /// A second seed to avoid seed collision.
+    ///
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs Seed2(int64 x) {
+      Attrs ret = *this;
+      ret.seed2_ = x;
+      return ret;
+    }
+
+    int64 seed_ = 0;
+    int64 seed2_ = 0;
+  };
+  TruncatedNormal(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                DataType dtype);
+  TruncatedNormal(const ::tensorflow::Scope& scope, ::tensorflow::Input shape,
+                DataType dtype, const TruncatedNormal::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Seed(int64 x) {
+    return Attrs().Seed(x);
+  }
+  static Attrs Seed2(int64 x) {
+    return Attrs().Seed2(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_RANDOM_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/random_ops_internal.h

@@ -0,0 +1,47 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_RANDOM_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_RANDOM_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup random_ops_internal Random Ops Internal
+/// @{
+
+/// Computes the derivative of a Gamma random sample w.r.t. `alpha`.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class RandomGammaGrad {
+ public:
+  RandomGammaGrad(const ::tensorflow::Scope& scope, ::tensorflow::Input alpha,
+                ::tensorflow::Input sample);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_RANDOM_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/resource_variable_ops.h

@@ -0,0 +1,587 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_RESOURCE_VARIABLE_OPS_H_
+#define TENSORFLOW_CC_OPS_RESOURCE_VARIABLE_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup resource_variable_ops Resource Variable Ops
+/// @{
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class AssignAddVariableOp {
+ public:
+  AssignAddVariableOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    resource, ::tensorflow::Input value);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class AssignSubVariableOp {
+ public:
+  AssignSubVariableOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    resource, ::tensorflow::Input value);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class AssignVariableOp {
+ public:
+  /// Optional attribute setters for AssignVariableOp
+  struct Attrs {
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs ValidateShape(bool x) {
+      Attrs ret = *this;
+      ret.validate_shape_ = x;
+      return ret;
+    }
+
+    bool validate_shape_ = false;
+  };
+  AssignVariableOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                 resource, ::tensorflow::Input value);
+  AssignVariableOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                 resource, ::tensorflow::Input value, const
+                 AssignVariableOp::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs ValidateShape(bool x) {
+    return Attrs().ValidateShape(x);
+  }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ConsumeMutexLock {
+ public:
+  ConsumeMutexLock(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                 mutex_lock);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class DestroyResourceOp {
+ public:
+  /// Optional attribute setters for DestroyResourceOp
+  struct Attrs {
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs IgnoreLookupError(bool x) {
+      Attrs ret = *this;
+      ret.ignore_lookup_error_ = x;
+      return ret;
+    }
+
+    bool ignore_lookup_error_ = true;
+  };
+  DestroyResourceOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  resource);
+  DestroyResourceOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  resource, const DestroyResourceOp::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs IgnoreLookupError(bool x) {
+    return Attrs().IgnoreLookupError(x);
+  }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class DisableCopyOnRead {
+ public:
+  DisableCopyOnRead(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  resource);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The mutex_lock tensor.
+class MutexLock {
+ public:
+  MutexLock(const ::tensorflow::Scope& scope, ::tensorflow::Input mutex);
+  operator ::tensorflow::Output() const { return mutex_lock; }
+  operator ::tensorflow::Input() const { return mutex_lock; }
+  ::tensorflow::Node* node() const { return mutex_lock.node(); }
+
+  Operation operation;
+  ::tensorflow::Output mutex_lock;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The resource tensor.
+class MutexV2 {
+ public:
+  /// Optional attribute setters for MutexV2
+  struct Attrs {
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+  };
+  MutexV2(const ::tensorflow::Scope& scope);
+  MutexV2(const ::tensorflow::Scope& scope, const MutexV2::Attrs& attrs);
+  operator ::tensorflow::Output() const { return resource; }
+  operator ::tensorflow::Input() const { return resource; }
+  ::tensorflow::Node* node() const { return resource.node(); }
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output resource;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The value tensor.
+class ReadVariableOp {
+ public:
+  ReadVariableOp(const ::tensorflow::Scope& scope, ::tensorflow::Input resource,
+               DataType dtype);
+  operator ::tensorflow::Output() const { return value; }
+  operator ::tensorflow::Input() const { return value; }
+  ::tensorflow::Node* node() const { return value.node(); }
+
+  Operation operation;
+  ::tensorflow::Output value;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class ResourceGather {
+ public:
+  /// Optional attribute setters for ResourceGather
+  struct Attrs {
+    /// Defaults to 0
+    TF_MUST_USE_RESULT Attrs BatchDims(int64 x) {
+      Attrs ret = *this;
+      ret.batch_dims_ = x;
+      return ret;
+    }
+
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs ValidateIndices(bool x) {
+      Attrs ret = *this;
+      ret.validate_indices_ = x;
+      return ret;
+    }
+
+    int64 batch_dims_ = 0;
+    bool validate_indices_ = true;
+  };
+  ResourceGather(const ::tensorflow::Scope& scope, ::tensorflow::Input resource,
+               ::tensorflow::Input indices, DataType dtype);
+  ResourceGather(const ::tensorflow::Scope& scope, ::tensorflow::Input resource,
+               ::tensorflow::Input indices, DataType dtype, const
+               ResourceGather::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs BatchDims(int64 x) {
+    return Attrs().BatchDims(x);
+  }
+  static Attrs ValidateIndices(bool x) {
+    return Attrs().ValidateIndices(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class ResourceGatherNd {
+ public:
+  ResourceGatherNd(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                 resource, ::tensorflow::Input indices, DataType dtype);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterAdd {
+ public:
+  ResourceScatterAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterDiv {
+ public:
+  ResourceScatterDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterMax {
+ public:
+  ResourceScatterMax(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterMin {
+ public:
+  ResourceScatterMin(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterMul {
+ public:
+  ResourceScatterMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterSub {
+ public:
+  ResourceScatterSub(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource, ::tensorflow::Input indices, ::tensorflow::Input
+                   updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterUpdate {
+ public:
+  ResourceScatterUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      resource, ::tensorflow::Input indices,
+                      ::tensorflow::Input updates);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The resource tensor.
+class VarHandleOp {
+ public:
+  /// Optional attribute setters for VarHandleOp
+  struct Attrs {
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs DebugName(StringPiece x) {
+      Attrs ret = *this;
+      ret.debug_name_ = x;
+      return ret;
+    }
+
+    /// Defaults to []
+    TF_MUST_USE_RESULT Attrs AllowedDevices(const gtl::ArraySlice<::tensorflow::tstring>& x) {
+      Attrs ret = *this;
+      ret.allowed_devices_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+    StringPiece debug_name_ = "";
+    gtl::ArraySlice<::tensorflow::tstring> allowed_devices_ = {};
+  };
+  VarHandleOp(const ::tensorflow::Scope& scope, DataType dtype,
+            PartialTensorShape shape);
+  VarHandleOp(const ::tensorflow::Scope& scope, DataType dtype,
+            PartialTensorShape shape, const VarHandleOp::Attrs& attrs);
+  operator ::tensorflow::Output() const { return resource; }
+  operator ::tensorflow::Input() const { return resource; }
+  ::tensorflow::Node* node() const { return resource.node(); }
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+  static Attrs DebugName(StringPiece x) {
+    return Attrs().DebugName(x);
+  }
+  static Attrs AllowedDevices(const gtl::ArraySlice<::tensorflow::tstring>& x) {
+    return Attrs().AllowedDevices(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output resource;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The is_initialized tensor.
+class VarIsInitializedOp {
+ public:
+  VarIsInitializedOp(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   resource);
+  operator ::tensorflow::Output() const { return is_initialized; }
+  operator ::tensorflow::Input() const { return is_initialized; }
+  ::tensorflow::Node* node() const { return is_initialized.node(); }
+
+  Operation operation;
+  ::tensorflow::Output is_initialized;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class VariableShape {
+ public:
+  /// Optional attribute setters for VariableShape
+  struct Attrs {
+    /// Defaults to DT_INT32
+    TF_MUST_USE_RESULT Attrs OutType(DataType x) {
+      Attrs ret = *this;
+      ret.out_type_ = x;
+      return ret;
+    }
+
+    DataType out_type_ = DT_INT32;
+  };
+  VariableShape(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  VariableShape(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+              const VariableShape::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs OutType(DataType x) {
+    return Attrs().OutType(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `OutputList`: The values tensor.
+class _ReadVariablesOp {
+ public:
+  _ReadVariablesOp(const ::tensorflow::Scope& scope, ::tensorflow::InputList
+                 resources, const DataTypeSlice& dtypes);
+  ::tensorflow::Output operator[](size_t index) const { return values[index]; }
+
+
+  Operation operation;
+  ::tensorflow::OutputList values;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `OutputList`: The resources tensor.
+class _VarHandlesOp {
+ public:
+  _VarHandlesOp(const ::tensorflow::Scope& scope, const
+              gtl::ArraySlice<::tensorflow::tstring>& containers, const
+              gtl::ArraySlice<::tensorflow::tstring>& shared_names, int64 N,
+              const DataTypeSlice& dtypes, const
+              gtl::ArraySlice<PartialTensorShape>& shapes);
+  ::tensorflow::Output operator[](size_t index) const { return resources[index]; }
+
+
+  Operation operation;
+  ::tensorflow::OutputList resources;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_RESOURCE_VARIABLE_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/sparse_ops.h

@@ -0,0 +1,1814 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_SPARSE_OPS_H_
+#define TENSORFLOW_CC_OPS_SPARSE_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup sparse_ops Sparse Ops
+/// @{
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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]`.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: 1-D.  The handles of the `SparseTensor` now stored in the
+/// `SparseTensorsMap`.  Shape: `[N]`.
+class AddManySparseToTensorsMap {
+ public:
+  /// Optional attribute setters for AddManySparseToTensorsMap
+  struct Attrs {
+    /// The container name for the `SparseTensorsMap` created by this op.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// The shared name for the `SparseTensorsMap` created by this op.
+    /// If blank, the new Operation's unique name is used.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+  };
+  AddManySparseToTensorsMap(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                          sparse_indices, ::tensorflow::Input sparse_values,
+                          ::tensorflow::Input sparse_shape);
+  AddManySparseToTensorsMap(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                          sparse_indices, ::tensorflow::Input sparse_values,
+                          ::tensorflow::Input sparse_shape, const
+                          AddManySparseToTensorsMap::Attrs& attrs);
+  operator ::tensorflow::Output() const { return sparse_handles; }
+  operator ::tensorflow::Input() const { return sparse_handles; }
+  ::tensorflow::Node* node() const { return sparse_handles.node(); }
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output sparse_handles;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: 0-D.  The handle of the `SparseTensor` now stored in the
+/// `SparseTensorsMap`.
+class AddSparseToTensorsMap {
+ public:
+  /// Optional attribute setters for AddSparseToTensorsMap
+  struct Attrs {
+    /// The container name for the `SparseTensorsMap` created by this op.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// The shared name for the `SparseTensorsMap` created by this op.
+    /// If blank, the new Operation's unique name is used.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+  };
+  AddSparseToTensorsMap(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      sparse_indices, ::tensorflow::Input sparse_values,
+                      ::tensorflow::Input sparse_shape);
+  AddSparseToTensorsMap(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      sparse_indices, ::tensorflow::Input sparse_values,
+                      ::tensorflow::Input sparse_shape, const
+                      AddSparseToTensorsMap::Attrs& attrs);
+  operator ::tensorflow::Output() const { return sparse_handle; }
+  operator ::tensorflow::Input() const { return sparse_handle; }
+  ::tensorflow::Node* node() const { return sparse_handle.node(); }
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output sparse_handle;
+};
+
+/// 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]
+///
+/// Args:
+/// * scope: A Scope object
+/// * serialized_sparse: 2-D, The `N` serialized `SparseTensor` objects.
+/// Must have 3 columns.
+/// * dtype: The `dtype` of the serialized `SparseTensor` objects.
+///
+/// Returns:
+/// * `Output` sparse_indices
+/// * `Output` sparse_values
+/// * `Output` sparse_shape
+class DeserializeManySparse {
+ public:
+  DeserializeManySparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      serialized_sparse, DataType dtype);
+
+  Operation operation;
+  ::tensorflow::Output sparse_indices;
+  ::tensorflow::Output sparse_values;
+  ::tensorflow::Output sparse_shape;
+};
+
+/// 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]
+///
+/// Args:
+/// * scope: A Scope object
+/// * serialized_sparse: The serialized `SparseTensor` objects. The last dimension
+/// must have 3 columns.
+/// * dtype: The `dtype` of the serialized `SparseTensor` objects.
+///
+/// Returns:
+/// * `Output` sparse_indices
+/// * `Output` sparse_values
+/// * `Output` sparse_shape
+class DeserializeSparse {
+ public:
+  DeserializeSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  serialized_sparse, DataType dtype);
+
+  Operation operation;
+  ::tensorflow::Output sparse_indices;
+  ::tensorflow::Output sparse_values;
+  ::tensorflow::Output sparse_shape;
+};
+
+/// 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]`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Optional attributes (see `Attrs`):
+/// * out_type: The `dtype` to use for serialization; the supported types are `string`
+/// (default) and `variant`.
+///
+/// Returns:
+/// * `Output`: The serialized_sparse tensor.
+class SerializeManySparse {
+ public:
+  /// Optional attribute setters for SerializeManySparse
+  struct Attrs {
+    /// The `dtype` to use for serialization; the supported types are `string`
+    /// (default) and `variant`.
+    ///
+    /// Defaults to DT_STRING
+    TF_MUST_USE_RESULT Attrs OutType(DataType x) {
+      Attrs ret = *this;
+      ret.out_type_ = x;
+      return ret;
+    }
+
+    DataType out_type_ = DT_STRING;
+  };
+  SerializeManySparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    sparse_indices, ::tensorflow::Input sparse_values,
+                    ::tensorflow::Input sparse_shape);
+  SerializeManySparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    sparse_indices, ::tensorflow::Input sparse_values,
+                    ::tensorflow::Input sparse_shape, const
+                    SerializeManySparse::Attrs& attrs);
+  operator ::tensorflow::Output() const { return serialized_sparse; }
+  operator ::tensorflow::Input() const { return serialized_sparse; }
+  ::tensorflow::Node* node() const { return serialized_sparse.node(); }
+
+  static Attrs OutType(DataType x) {
+    return Attrs().OutType(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output serialized_sparse;
+};
+
+/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Optional attributes (see `Attrs`):
+/// * out_type: The `dtype` to use for serialization; the supported types are `string`
+/// (default) and `variant`.
+///
+/// Returns:
+/// * `Output`: The serialized_sparse tensor.
+class SerializeSparse {
+ public:
+  /// Optional attribute setters for SerializeSparse
+  struct Attrs {
+    /// The `dtype` to use for serialization; the supported types are `string`
+    /// (default) and `variant`.
+    ///
+    /// Defaults to DT_STRING
+    TF_MUST_USE_RESULT Attrs OutType(DataType x) {
+      Attrs ret = *this;
+      ret.out_type_ = x;
+      return ret;
+    }
+
+    DataType out_type_ = DT_STRING;
+  };
+  SerializeSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                sparse_indices, ::tensorflow::Input sparse_values,
+                ::tensorflow::Input sparse_shape);
+  SerializeSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                sparse_indices, ::tensorflow::Input sparse_values,
+                ::tensorflow::Input sparse_shape, const SerializeSparse::Attrs&
+                attrs);
+  operator ::tensorflow::Output() const { return serialized_sparse; }
+  operator ::tensorflow::Input() const { return serialized_sparse; }
+  ::tensorflow::Node* node() const { return serialized_sparse.node(); }
+
+  static Attrs OutType(DataType x) {
+    return Attrs().OutType(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output serialized_sparse;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output` sum_indices
+/// * `Output` sum_values
+/// * `Output` sum_shape
+class SparseAdd {
+ public:
+  SparseAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input a_indices,
+          ::tensorflow::Input a_values, ::tensorflow::Input a_shape,
+          ::tensorflow::Input b_indices, ::tensorflow::Input b_values,
+          ::tensorflow::Input b_shape, ::tensorflow::Input thresh);
+
+  Operation operation;
+  ::tensorflow::Output sum_indices;
+  ::tensorflow::Output sum_values;
+  ::tensorflow::Output sum_shape;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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]`.
+///
+/// Returns:
+/// * `Output` a_val_grad: 1-D with shape `[nnz(A)]`. The gradient with respect to the
+/// non-empty values of A.
+/// * `Output` b_val_grad: 1-D with shape `[nnz(B)]`. The gradient with respect to the
+/// non-empty values of B.
+class SparseAddGrad {
+ public:
+  SparseAddGrad(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              backprop_val_grad, ::tensorflow::Input a_indices,
+              ::tensorflow::Input b_indices, ::tensorflow::Input sum_indices);
+
+  Operation operation;
+  ::tensorflow::Output a_val_grad;
+  ::tensorflow::Output b_val_grad;
+};
+
+/// 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          ]
+///
+/// Args:
+/// * scope: A Scope object
+/// * indices: 2-D.  Indices of each input `SparseTensor`.
+/// * values: 1-D.  Non-empty values of each `SparseTensor`.
+/// * shapes: 1-D.  Shapes of each `SparseTensor`.
+/// * concat_dim: Dimension to concatenate along. Must be in range [-rank, rank),
+/// where rank is the number of dimensions in each input `SparseTensor`.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+/// * `Output` output_values: 1-D.  Non-empty values of the concatenated `SparseTensor`.
+/// * `Output` output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+class SparseConcat {
+ public:
+  SparseConcat(const ::tensorflow::Scope& scope, ::tensorflow::InputList indices,
+             ::tensorflow::InputList values, ::tensorflow::InputList shapes,
+             int64 concat_dim);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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")))
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+/// * 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.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+/// * `Output` output_values: 1-D.  Non-empty values of the concatenated or hashed
+/// `SparseTensor`.
+/// * `Output` output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+class SparseCross {
+ public:
+  SparseCross(const ::tensorflow::Scope& scope, ::tensorflow::InputList indices,
+            ::tensorflow::InputList values, ::tensorflow::InputList shapes,
+            ::tensorflow::InputList dense_inputs, bool hashed_output, int64
+            num_buckets, int64 hash_key, DataType out_type, DataType
+            internal_type);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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")))
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+/// * num_buckets: It is used if hashed_output is true.
+/// output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+/// * strong_hash: boolean, if true, siphash with salt will be used instead of farmhash.
+/// * salt: Specify the salt that will be used by the siphash function.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+/// * `Output` output_values: 1-D.  Non-empty values of the concatenated or hashed
+/// `SparseTensor`.
+/// * `Output` output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+class SparseCrossHashed {
+ public:
+  SparseCrossHashed(const ::tensorflow::Scope& scope, ::tensorflow::InputList
+                  indices, ::tensorflow::InputList values,
+                  ::tensorflow::InputList shapes, ::tensorflow::InputList
+                  dense_inputs, ::tensorflow::Input num_buckets,
+                  ::tensorflow::Input strong_hash, ::tensorflow::Input salt);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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")))
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+/// * sep: string used when joining a list of string inputs, can be used as separator later.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+/// * `Output` output_values: 1-D.  Non-empty values of the concatenated or hashed
+/// `SparseTensor`.
+/// * `Output` output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+class SparseCrossV2 {
+ public:
+  SparseCrossV2(const ::tensorflow::Scope& scope, ::tensorflow::InputList
+              indices, ::tensorflow::InputList values, ::tensorflow::InputList
+              shapes, ::tensorflow::InputList dense_inputs, ::tensorflow::Input
+              sep);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output`: 1-D.  The `N` values that are operated on.
+class SparseDenseCwiseAdd {
+ public:
+  SparseDenseCwiseAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    sp_indices, ::tensorflow::Input sp_values,
+                    ::tensorflow::Input sp_shape, ::tensorflow::Input dense);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output`: 1-D.  The `N` values that are operated on.
+class SparseDenseCwiseDiv {
+ public:
+  SparseDenseCwiseDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    sp_indices, ::tensorflow::Input sp_values,
+                    ::tensorflow::Input sp_shape, ::tensorflow::Input dense);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output`: 1-D.  The `N` values that are operated on.
+class SparseDenseCwiseMul {
+ public:
+  SparseDenseCwiseMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    sp_indices, ::tensorflow::Input sp_values,
+                    ::tensorflow::Input sp_shape, ::tensorflow::Input dense);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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, :]
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output` output_indices
+/// * `Output` output_values: 1-D. the values of the filled sparse tensor.
+/// * `Output` empty_row_indicator: 1-D. whether the dense row was missing in the
+/// input sparse tensor.
+/// * `Output` reverse_index_map: 1-D. a map from the input indices to the output indices.
+class SparseFillEmptyRows {
+ public:
+  SparseFillEmptyRows(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    indices, ::tensorflow::Input values, ::tensorflow::Input
+                    dense_shape, ::tensorflow::Input default_value);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output empty_row_indicator;
+  ::tensorflow::Output reverse_index_map;
+};
+
+/// 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})
+///
+/// Args:
+/// * scope: A Scope object
+/// * reverse_index_map: 1-D.  The reverse index map from SparseFillEmptyRows.
+/// * grad_values: 1-D.  The gradients from backprop.
+///
+/// Returns:
+/// * `Output` d_values: 1-D.  The backprop into values.
+/// * `Output` d_default_value: 0-D.  The backprop into default_value.
+class SparseFillEmptyRowsGrad {
+ public:
+  SparseFillEmptyRowsGrad(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                        reverse_index_map, ::tensorflow::Input grad_values);
+
+  Operation operation;
+  ::tensorflow::Output d_values;
+  ::tensorflow::Output d_default_value;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// Returns:
+/// * `Output`: `R-K`-D.  The reduced Tensor.
+class SparseReduceMax {
+ public:
+  /// Optional attribute setters for SparseReduceMax
+  struct Attrs {
+    /// If true, retain reduced dimensions with length 1.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs KeepDims(bool x) {
+      Attrs ret = *this;
+      ret.keep_dims_ = x;
+      return ret;
+    }
+
+    bool keep_dims_ = false;
+  };
+  SparseReduceMax(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_indices, ::tensorflow::Input input_values,
+                ::tensorflow::Input input_shape, ::tensorflow::Input
+                reduction_axes);
+  SparseReduceMax(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_indices, ::tensorflow::Input input_values,
+                ::tensorflow::Input input_shape, ::tensorflow::Input
+                reduction_axes, const SparseReduceMax::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs KeepDims(bool x) {
+    return Attrs().KeepDims(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// Returns:
+/// * `Output` output_indices
+/// * `Output` output_values
+/// * `Output` output_shape
+class SparseReduceMaxSparse {
+ public:
+  /// Optional attribute setters for SparseReduceMaxSparse
+  struct Attrs {
+    /// If true, retain reduced dimensions with length 1.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs KeepDims(bool x) {
+      Attrs ret = *this;
+      ret.keep_dims_ = x;
+      return ret;
+    }
+
+    bool keep_dims_ = false;
+  };
+  SparseReduceMaxSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      input_indices, ::tensorflow::Input input_values,
+                      ::tensorflow::Input input_shape, ::tensorflow::Input
+                      reduction_axes);
+  SparseReduceMaxSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      input_indices, ::tensorflow::Input input_values,
+                      ::tensorflow::Input input_shape, ::tensorflow::Input
+                      reduction_axes, const SparseReduceMaxSparse::Attrs&
+                      attrs);
+
+  static Attrs KeepDims(bool x) {
+    return Attrs().KeepDims(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// Returns:
+/// * `Output`: `R-K`-D.  The reduced Tensor.
+class SparseReduceSum {
+ public:
+  /// Optional attribute setters for SparseReduceSum
+  struct Attrs {
+    /// If true, retain reduced dimensions with length 1.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs KeepDims(bool x) {
+      Attrs ret = *this;
+      ret.keep_dims_ = x;
+      return ret;
+    }
+
+    bool keep_dims_ = false;
+  };
+  SparseReduceSum(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_indices, ::tensorflow::Input input_values,
+                ::tensorflow::Input input_shape, ::tensorflow::Input
+                reduction_axes);
+  SparseReduceSum(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                input_indices, ::tensorflow::Input input_values,
+                ::tensorflow::Input input_shape, ::tensorflow::Input
+                reduction_axes, const SparseReduceSum::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs KeepDims(bool x) {
+    return Attrs().KeepDims(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// Returns:
+/// * `Output` output_indices
+/// * `Output` output_values
+/// * `Output` output_shape
+class SparseReduceSumSparse {
+ public:
+  /// Optional attribute setters for SparseReduceSumSparse
+  struct Attrs {
+    /// If true, retain reduced dimensions with length 1.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs KeepDims(bool x) {
+      Attrs ret = *this;
+      ret.keep_dims_ = x;
+      return ret;
+    }
+
+    bool keep_dims_ = false;
+  };
+  SparseReduceSumSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      input_indices, ::tensorflow::Input input_values,
+                      ::tensorflow::Input input_shape, ::tensorflow::Input
+                      reduction_axes);
+  SparseReduceSumSparse(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      input_indices, ::tensorflow::Input input_values,
+                      ::tensorflow::Input input_shape, ::tensorflow::Input
+                      reduction_axes, const SparseReduceSumSparse::Attrs&
+                      attrs);
+
+  static Attrs KeepDims(bool x) {
+    return Attrs().KeepDims(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  `N x R` matrix with the same indices as input_indices, but
+/// in canonical row-major ordering.
+/// * `Output` output_values: 1-D.  `N` non-empty values corresponding to `output_indices`.
+class SparseReorder {
+ public:
+  SparseReorder(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              input_indices, ::tensorflow::Input input_values,
+              ::tensorflow::Input input_shape);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+};
+
+/// 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`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  `N x R_out` matrix with the updated indices of non-empty
+/// values in the output SparseTensor.
+/// * `Output` 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.
+class SparseReshape {
+ public:
+  SparseReshape(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              input_indices, ::tensorflow::Input input_shape,
+              ::tensorflow::Input new_shape);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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  ]
+///     [      ]
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output` output_indices
+/// * `Output` output_values: A list of 1-D tensors represents the values of the output sparse
+/// tensors.
+/// * `Output` output_shape: A list of 1-D tensors represents the shape of the output sparse
+/// tensors.
+class SparseSlice {
+ public:
+  SparseSlice(const ::tensorflow::Scope& scope, ::tensorflow::Input indices,
+            ::tensorflow::Input values, ::tensorflow::Input shape,
+            ::tensorflow::Input start, ::tensorflow::Input size);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+  ::tensorflow::Output output_shape;
+};
+
+/// 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`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Returns:
+/// * `Output`: 1-D. The gradient with respect to the non-empty values of input `SparseTensor`.
+class SparseSliceGrad {
+ public:
+  SparseSliceGrad(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                backprop_val_grad, ::tensorflow::Input input_indices,
+                ::tensorflow::Input input_start, ::tensorflow::Input
+                output_indices);
+  operator ::tensorflow::Output() const { return val_grad; }
+  operator ::tensorflow::Input() const { return val_grad; }
+  ::tensorflow::Node* node() const { return val_grad.node(); }
+
+  Operation operation;
+  ::tensorflow::Output val_grad;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Returns:
+/// * `Output`: 1-D.  The `NNZ` values for the result `SparseTensor`.
+class SparseSoftmax {
+ public:
+  SparseSoftmax(const ::tensorflow::Scope& scope, ::tensorflow::Input sp_indices,
+              ::tensorflow::Input sp_values, ::tensorflow::Input sp_shape);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Returns the element-wise max of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// Args:
+/// * scope: A Scope object
+/// * a_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+/// SparseTensor, in the canonical lexicographic ordering.
+/// * a_values: 1-D.  `N` non-empty values corresponding to `a_indices`.
+/// * a_shape: 1-D.  Shape of the input SparseTensor.
+/// * b_indices: counterpart to `a_indices` for the other operand.
+/// * b_values: counterpart to `a_values` for the other operand; must be of the same dtype.
+/// * b_shape: counterpart to `a_shape` for the other operand; the two shapes must be equal.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  The indices of the output SparseTensor.
+/// * `Output` output_values: 1-D.  The values of the output SparseTensor.
+class SparseSparseMaximum {
+ public:
+  SparseSparseMaximum(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    a_indices, ::tensorflow::Input a_values,
+                    ::tensorflow::Input a_shape, ::tensorflow::Input b_indices,
+                    ::tensorflow::Input b_values, ::tensorflow::Input b_shape);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+};
+
+/// Returns the element-wise min of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// Args:
+/// * scope: A Scope object
+/// * a_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+/// SparseTensor, in the canonical lexicographic ordering.
+/// * a_values: 1-D.  `N` non-empty values corresponding to `a_indices`.
+/// * a_shape: 1-D.  Shape of the input SparseTensor.
+/// * b_indices: counterpart to `a_indices` for the other operand.
+/// * b_values: counterpart to `a_values` for the other operand; must be of the same dtype.
+/// * b_shape: counterpart to `a_shape` for the other operand; the two shapes must be equal.
+///
+/// Returns:
+/// * `Output` output_indices: 2-D.  The indices of the output SparseTensor.
+/// * `Output` output_values: 1-D.  The values of the output SparseTensor.
+class SparseSparseMinimum {
+ public:
+  SparseSparseMinimum(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    a_indices, ::tensorflow::Input a_values,
+                    ::tensorflow::Input a_shape, ::tensorflow::Input b_indices,
+                    ::tensorflow::Input b_values, ::tensorflow::Input b_shape);
+
+  Operation operation;
+  ::tensorflow::Output output_indices;
+  ::tensorflow::Output output_values;
+};
+
+/// 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  ]
+///     [      ]
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+/// * num_split: The number of ways to split.
+///
+/// Returns:
+/// * `OutputList` output_indices
+/// * `OutputList` output_values: A list of 1-D tensors represents the values of the output sparse
+/// tensors.
+/// * `OutputList` output_shape: A list of 1-D tensors represents the shape of the output sparse
+/// tensors.
+class SparseSplit {
+ public:
+  SparseSplit(const ::tensorflow::Scope& scope, ::tensorflow::Input split_dim,
+            ::tensorflow::Input indices, ::tensorflow::Input values,
+            ::tensorflow::Input shape, int64 num_split);
+
+  Operation operation;
+  ::tensorflow::OutputList output_indices;
+  ::tensorflow::OutputList output_values;
+  ::tensorflow::OutputList output_shape;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class SparseTensorDenseAdd {
+ public:
+  SparseTensorDenseAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                     a_indices, ::tensorflow::Input a_values,
+                     ::tensorflow::Input a_shape, ::tensorflow::Input b);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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).
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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).
+///
+/// Returns:
+/// * `Output`: The product tensor.
+class SparseTensorDenseMatMul {
+ public:
+  /// Optional attribute setters for SparseTensorDenseMatMul
+  struct Attrs {
+    /// Use the adjoint of A in the matrix multiply.  If A is complex, this
+    /// is transpose(conj(A)).  Otherwise it's transpose(A).
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs AdjointA(bool x) {
+      Attrs ret = *this;
+      ret.adjoint_a_ = x;
+      return ret;
+    }
+
+    /// Use the adjoint of B in the matrix multiply.  If B is complex, this
+    /// is transpose(conj(B)).  Otherwise it's transpose(B).
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs AdjointB(bool x) {
+      Attrs ret = *this;
+      ret.adjoint_b_ = x;
+      return ret;
+    }
+
+    bool adjoint_a_ = false;
+    bool adjoint_b_ = false;
+  };
+  SparseTensorDenseMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                        a_indices, ::tensorflow::Input a_values,
+                        ::tensorflow::Input a_shape, ::tensorflow::Input b);
+  SparseTensorDenseMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                        a_indices, ::tensorflow::Input a_values,
+                        ::tensorflow::Input a_shape, ::tensorflow::Input b,
+                        const SparseTensorDenseMatMul::Attrs& attrs);
+  operator ::tensorflow::Output() const { return product; }
+  operator ::tensorflow::Input() const { return product; }
+  ::tensorflow::Node* node() const { return product.node(); }
+
+  static Attrs AdjointA(bool x) {
+    return Attrs().AdjointA(x);
+  }
+  static Attrs AdjointB(bool x) {
+    return Attrs().AdjointB(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output product;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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`.
+///
+/// Optional attributes (see `Attrs`):
+/// * validate_indices: If true, indices are checked to make sure they are sorted in
+/// lexicographic order and that there are no repeats.
+///
+/// Returns:
+/// * `Output`: Dense output tensor of shape `output_shape`.
+class SparseToDense {
+ public:
+  /// Optional attribute setters for SparseToDense
+  struct Attrs {
+    /// If true, indices are checked to make sure they are sorted in
+    /// lexicographic order and that there are no repeats.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs ValidateIndices(bool x) {
+      Attrs ret = *this;
+      ret.validate_indices_ = x;
+      return ret;
+    }
+
+    bool validate_indices_ = true;
+  };
+  SparseToDense(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              sparse_indices, ::tensorflow::Input output_shape,
+              ::tensorflow::Input sparse_values, ::tensorflow::Input
+              default_value);
+  SparseToDense(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              sparse_indices, ::tensorflow::Input output_shape,
+              ::tensorflow::Input sparse_values, ::tensorflow::Input
+              default_value, const SparseToDense::Attrs& attrs);
+  operator ::tensorflow::Output() const { return dense; }
+  operator ::tensorflow::Input() const { return dense; }
+  ::tensorflow::Node* node() const { return dense.node(); }
+
+  static Attrs ValidateIndices(bool x) {
+    return Attrs().ValidateIndices(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output dense;
+};
+
+/// 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]
+/// ```
+///
+/// Args:
+/// * scope: A Scope object
+/// * sparse_handles: 1-D, The `N` serialized `SparseTensor` objects.
+/// Shape: `[N]`.
+/// * dtype: The `dtype` of the `SparseTensor` objects stored in the
+/// `SparseTensorsMap`.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output` sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+/// * `Output` sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+/// * `Output` sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+class TakeManySparseFromTensorsMap {
+ public:
+  /// Optional attribute setters for TakeManySparseFromTensorsMap
+  struct Attrs {
+    /// The container name for the `SparseTensorsMap` read by this op.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// 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.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+  };
+  TakeManySparseFromTensorsMap(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input sparse_handles, DataType
+                             dtype);
+  TakeManySparseFromTensorsMap(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input sparse_handles, DataType
+                             dtype, const TakeManySparseFromTensorsMap::Attrs&
+                             attrs);
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output sparse_indices;
+  ::tensorflow::Output sparse_values;
+  ::tensorflow::Output sparse_shape;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_SPARSE_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/sparse_ops_internal.h

@@ -0,0 +1,28 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_SPARSE_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_SPARSE_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup sparse_ops_internal Sparse Ops Internal
+/// @{
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_SPARSE_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/standard_ops.h

@@ -0,0 +1,40 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_OPS_STANDARD_OPS_H_
+#define TENSORFLOW_CC_OPS_STANDARD_OPS_H_
+
+#include "tensorflow/cc/ops/array_ops.h"
+#include "tensorflow/cc/ops/candidate_sampling_ops.h"
+#include "tensorflow/cc/ops/const_op.h"
+#include "tensorflow/cc/ops/control_flow_ops.h"
+#include "tensorflow/cc/ops/data_flow_ops.h"
+#include "tensorflow/cc/ops/image_ops.h"
+#include "tensorflow/cc/ops/io_ops.h"
+#include "tensorflow/cc/ops/linalg_ops.h"
+#include "tensorflow/cc/ops/logging_ops.h"
+#include "tensorflow/cc/ops/lookup_ops.h"
+#include "tensorflow/cc/ops/math_ops.h"
+#include "tensorflow/cc/ops/nn_ops.h"
+#include "tensorflow/cc/ops/no_op.h"
+#include "tensorflow/cc/ops/parsing_ops.h"
+#include "tensorflow/cc/ops/random_ops.h"
+#include "tensorflow/cc/ops/sparse_ops.h"
+#include "tensorflow/cc/ops/state_ops.h"
+#include "tensorflow/cc/ops/string_ops.h"
+#include "tensorflow/cc/ops/training_ops.h"
+#include "tensorflow/cc/ops/user_ops.h"
+
+#endif  // TENSORFLOW_CC_OPS_STANDARD_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/state_ops.h

@@ -0,0 +1,1519 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_STATE_OPS_H_
+#define TENSORFLOW_CC_OPS_STATE_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup state_ops State Ops
+/// @{
+
+/// Update 'ref' by assigning 'value' to it.
+///
+/// This operation outputs "ref" after the assignment is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node. May be uninitialized.
+/// * value: The value to be assigned to the variable.
+///
+/// Optional attributes (see `Attrs`):
+/// * validate_shape: If true, the operation will validate that the shape
+/// of 'value' matches the shape of the Tensor being assigned to.  If false,
+/// 'ref' will take on the shape of 'value'.
+/// * use_locking: If True, the assignment will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as "ref".  Returned as a convenience for operations that want
+/// to use the new value after the variable has been reset.
+class Assign {
+ public:
+  /// Optional attribute setters for Assign
+  struct Attrs {
+    /// If true, the operation will validate that the shape
+    /// of 'value' matches the shape of the Tensor being assigned to.  If false,
+    /// 'ref' will take on the shape of 'value'.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs ValidateShape(bool x) {
+      Attrs ret = *this;
+      ret.validate_shape_ = x;
+      return ret;
+    }
+
+    /// If True, the assignment will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool validate_shape_ = true;
+    bool use_locking_ = true;
+  };
+  Assign(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+       ::tensorflow::Input value);
+  Assign(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+       ::tensorflow::Input value, const Assign::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs ValidateShape(bool x) {
+    return Attrs().ValidateShape(x);
+  }
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Update 'ref' by adding 'value' to it.
+///
+/// This operation outputs "ref" after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * value: The value to be added to the variable.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the addition will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as "ref".  Returned as a convenience for operations that want
+/// to use the new value after the variable has been updated.
+class AssignAdd {
+ public:
+  /// Optional attribute setters for AssignAdd
+  struct Attrs {
+    /// If True, the addition will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  AssignAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+          ::tensorflow::Input value);
+  AssignAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+          ::tensorflow::Input value, const AssignAdd::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Update 'ref' by subtracting 'value' from it.
+///
+/// This operation outputs "ref" after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * value: The value to be subtracted to the variable.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the subtraction will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as "ref".  Returned as a convenience for operations that want
+/// to use the new value after the variable has been updated.
+class AssignSub {
+ public:
+  /// Optional attribute setters for AssignSub
+  struct Attrs {
+    /// If True, the subtraction will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  AssignSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+          ::tensorflow::Input value);
+  AssignSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+          ::tensorflow::Input value, const AssignSub::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Increments 'ref' until it reaches 'limit'.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a scalar `Variable` node.
+/// * limit: If incrementing ref would bring it above limit, instead generates an
+/// 'OutOfRange' error.
+///
+/// Returns:
+/// * `Output`: A copy of the input before increment. If nothing else modifies the
+/// input, the values produced will all be distinct.
+class CountUpTo {
+ public:
+  CountUpTo(const ::tensorflow::Scope& scope, ::tensorflow::Input ref, int64
+          limit);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Destroys the temporary variable and returns its final value.
+///
+/// Sets output to the value of the Tensor pointed to by 'ref', then destroys
+/// the temporary variable called 'var_name'.
+/// All other uses of 'ref' *must* have executed before this op.
+/// This is typically achieved by chaining the ref through each assign op, or by
+/// using control dependencies.
+///
+/// Outputs the final value of the tensor pointed to by 'ref'.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A reference to the temporary variable tensor.
+/// * var_name: Name of the temporary variable, usually the name of the matching
+/// 'TemporaryVariable' op.
+///
+/// Returns:
+/// * `Output`: The value tensor.
+class DestroyTemporaryVariable {
+ public:
+  DestroyTemporaryVariable(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                         ref, StringPiece var_name);
+  operator ::tensorflow::Output() const { return value; }
+  operator ::tensorflow::Input() const { return value; }
+  ::tensorflow::Node* node() const { return value.node(); }
+
+  Operation operation;
+  ::tensorflow::Output value;
+};
+
+/// Checks whether a tensor has been initialized.
+///
+/// Outputs boolean scalar indicating whether the tensor has been initialized.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node. May be uninitialized.
+///
+/// Returns:
+/// * `Output`: The is_initialized tensor.
+class IsVariableInitialized {
+ public:
+  IsVariableInitialized(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                      ref);
+  operator ::tensorflow::Output() const { return is_initialized; }
+  operator ::tensorflow::Input() const { return is_initialized; }
+  ::tensorflow::Node* node() const { return is_initialized.node(); }
+
+  Operation operation;
+  ::tensorflow::Output is_initialized;
+};
+
+/// Increments variable pointed to by 'resource' until it reaches 'limit'.
+///
+/// Args:
+/// * scope: A Scope object
+/// * resource: Should be from a scalar `Variable` node.
+/// * limit: If incrementing ref would bring it above limit, instead generates an
+/// 'OutOfRange' error.
+///
+/// Returns:
+/// * `Output`: A copy of the input before increment. If nothing else modifies the
+/// input, the values produced will all be distinct.
+class ResourceCountUpTo {
+ public:
+  ResourceCountUpTo(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                  resource, int64 limit, DataType T);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterNdAdd {
+ public:
+  /// Optional attribute setters for ResourceScatterNdAdd
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ResourceScatterNdAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ResourceScatterNdAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates,
+                     const ResourceScatterNdAdd::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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 whose element wise max is taken with ref
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterNdMax {
+ public:
+  /// Optional attribute setters for ResourceScatterNdMax
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ResourceScatterNdMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ResourceScatterNdMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates,
+                     const ResourceScatterNdMax::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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 whose element wise min is taken with ref.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterNdMin {
+ public:
+  /// Optional attribute setters for ResourceScatterNdMin
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ResourceScatterNdMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ResourceScatterNdMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates,
+                     const ResourceScatterNdMin::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterNdSub {
+ public:
+  /// Optional attribute setters for ResourceScatterNdSub
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ResourceScatterNdSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ResourceScatterNdSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                     ::tensorflow::Input indices, ::tensorflow::Input updates,
+                     const ResourceScatterNdSub::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceScatterNdUpdate {
+ public:
+  /// Optional attribute setters for ResourceScatterNdUpdate
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ResourceScatterNdUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                        ref, ::tensorflow::Input indices, ::tensorflow::Input
+                        updates);
+  ResourceScatterNdUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                        ref, ::tensorflow::Input indices, ::tensorflow::Input
+                        updates, const ResourceScatterNdUpdate::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// Adds sparse updates to a variable reference.
+///
+/// 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, ...]
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// 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>
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: 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`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the addition will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterAdd {
+ public:
+  /// Optional attribute setters for ScatterAdd
+  struct Attrs {
+    /// If True, the addition will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterAdd::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Divides a variable reference by sparse updates.
+///
+/// This operation computes
+///
+/// ```python
+///     # 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, ...]
+/// ```
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions divide.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of values that `ref` is divided by.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the operation will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterDiv {
+ public:
+  /// Optional attribute setters for ScatterDiv
+  struct Attrs {
+    /// If True, the operation will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterDiv::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Reduces sparse updates into a variable reference 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, ...])
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions combine.
+///
+/// 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>
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of updated values to reduce into `ref`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the update will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterMax {
+ public:
+  /// Optional attribute setters for ScatterMax
+  struct Attrs {
+    /// If True, the update will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterMax::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Reduces sparse updates into a variable reference 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, ...])
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions combine.
+///
+/// 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>
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of updated values to reduce into `ref`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the update will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterMin {
+ public:
+  /// Optional attribute setters for ScatterMin
+  struct Attrs {
+    /// If True, the update will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterMin::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Multiplies sparse updates into a variable reference.
+///
+/// This operation computes
+///
+/// ```python
+///     # 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, ...]
+/// ```
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// 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 = []`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of updated values to multiply to `ref`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the operation will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterMul {
+ public:
+  /// Optional attribute setters for ScatterMul
+  struct Attrs {
+    /// If True, the operation will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterMul(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterMul(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterMul::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// 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])
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A mutable Tensor. Should be from a Variable node.
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Same as ref. Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterNdAdd {
+ public:
+  /// Optional attribute setters for ScatterNdAdd
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterNdAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterNdAdd(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates, const
+             ScatterNdAdd::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Applies sparse subtraction to individual values or slices in a Variable.
+///
+/// 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 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])
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A mutable Tensor. Should be from a Variable node.
+/// * 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 subtract from ref.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Same as ref. Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterNdSub {
+ public:
+  /// Optional attribute setters for ScatterNdSub
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterNdSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterNdSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates, const
+             ScatterNdSub::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// 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.
+///
+/// See also `tf.scatter_update` and `tf.batch_scatter_update`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A mutable Tensor. Should be from a Variable node.
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Same as ref. Returned as a convenience for operations that want to
+/// use the updated values after the update is done.
+class ScatterNdUpdate {
+ public:
+  /// Optional attribute setters for ScatterNdUpdate
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ScatterNdUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterNdUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+                ::tensorflow::Input indices, ::tensorflow::Input updates, const
+                ScatterNdUpdate::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Subtracts sparse updates to a variable reference.
+///
+/// ```python
+///     # 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, ...]
+/// ```
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their (negated) 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/ScatterSub.png" alt>
+/// </div>
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of updated values to subtract from `ref`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the subtraction will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterSub {
+ public:
+  /// Optional attribute setters for ScatterSub
+  struct Attrs {
+    /// If True, the subtraction will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterSub(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+           ::tensorflow::Input indices, ::tensorflow::Input updates, const
+           ScatterSub::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Applies sparse updates to a variable reference.
+///
+/// This operation computes
+///
+/// ```python
+///     # 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, ...]
+/// ```
+///
+/// This operation outputs `ref` after the update is done.
+/// This makes it easier to chain operations that need to use the reset value.
+///
+/// If values in `ref` is to be updated more than once, because there are
+/// duplicate entries in `indices`, the order at which the updates happen
+/// for each value is undefined.
+///
+/// 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/ScatterUpdate.png" alt>
+/// </div>
+///
+/// See also `tf.batch_scatter_update` and `tf.scatter_nd_update`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: Should be from a `Variable` node.
+/// * indices: A tensor of indices into the first dimension of `ref`.
+/// * updates: A tensor of updated values to store in `ref`.
+///
+/// Optional attributes (see `Attrs`):
+/// * use_locking: If True, the assignment will be protected by a lock;
+/// otherwise the behavior is undefined, but may exhibit less contention.
+///
+/// Returns:
+/// * `Output`: = Same as `ref`.  Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterUpdate {
+ public:
+  /// Optional attribute setters for ScatterUpdate
+  struct Attrs {
+    /// If True, the assignment will be protected by a lock;
+    /// otherwise the behavior is undefined, but may exhibit less contention.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = true;
+  };
+  ScatterUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+              ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterUpdate(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+              ::tensorflow::Input indices, ::tensorflow::Input updates, const
+              ScatterUpdate::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Returns a tensor that may be mutated, but only persists within a single step.
+///
+/// This is an experimental op for internal use only and it is possible to use this
+/// op in unsafe ways.  DO NOT USE unless you fully understand the risks.
+///
+/// It is the caller's responsibility to ensure that 'ref' is eventually passed to a
+/// matching 'DestroyTemporaryVariable' op after all other uses have completed.
+///
+/// Outputs a ref to the tensor state so it may be read or modified.
+///
+///   E.g.
+///       var = state_ops._temporary_variable([1, 2], types.float_)
+///       var_name = var.op.name
+///       var = state_ops.assign(var, [[4.0, 5.0]])
+///       var = state_ops.assign_add(var, [[6.0, 7.0]])
+///       final = state_ops._destroy_temporary_variable(var, var_name=var_name)
+///
+/// Args:
+/// * scope: A Scope object
+/// * shape: The shape of the variable tensor.
+/// * dtype: The type of elements in the variable tensor.
+///
+/// Optional attributes (see `Attrs`):
+/// * var_name: Overrides the name used for the temporary variable resource. Default
+/// value is the name of the 'TemporaryVariable' op (which is guaranteed unique).
+///
+/// Returns:
+/// * `Output`: A reference to the variable tensor.
+class TemporaryVariable {
+ public:
+  /// Optional attribute setters for TemporaryVariable
+  struct Attrs {
+    /// Overrides the name used for the temporary variable resource. Default
+    /// value is the name of the 'TemporaryVariable' op (which is guaranteed unique).
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs VarName(StringPiece x) {
+      Attrs ret = *this;
+      ret.var_name_ = x;
+      return ret;
+    }
+
+    StringPiece var_name_ = "";
+  };
+  TemporaryVariable(const ::tensorflow::Scope& scope, PartialTensorShape shape,
+                  DataType dtype);
+  TemporaryVariable(const ::tensorflow::Scope& scope, PartialTensorShape shape,
+                  DataType dtype, const TemporaryVariable::Attrs& attrs);
+  operator ::tensorflow::Output() const { return ref; }
+  operator ::tensorflow::Input() const { return ref; }
+  ::tensorflow::Node* node() const { return ref.node(); }
+
+  static Attrs VarName(StringPiece x) {
+    return Attrs().VarName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output ref;
+};
+
+/// Holds state in the form of a tensor that persists across steps.
+///
+/// Outputs a ref to the tensor state so it may be read or modified.
+/// TODO(zhifengc/mrry): Adds a pointer to a more detail document
+/// about sharing states in tensorflow.
+///
+/// Args:
+/// * scope: A Scope object
+/// * shape: The shape of the variable tensor.
+/// * dtype: The type of elements in the variable tensor.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: A reference to the variable tensor.
+class Variable {
+ public:
+  /// Optional attribute setters for Variable
+  struct Attrs {
+    /// If non-empty, this variable is placed in the given container.
+    /// Otherwise, a default container is used.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Container(StringPiece x) {
+      Attrs ret = *this;
+      ret.container_ = x;
+      return ret;
+    }
+
+    /// If non-empty, this variable is named in the given bucket
+    /// with this shared_name. Otherwise, the node name is used instead.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs SharedName(StringPiece x) {
+      Attrs ret = *this;
+      ret.shared_name_ = x;
+      return ret;
+    }
+
+    StringPiece container_ = "";
+    StringPiece shared_name_ = "";
+  };
+  Variable(const ::tensorflow::Scope& scope, PartialTensorShape shape, DataType
+         dtype);
+  Variable(const ::tensorflow::Scope& scope, PartialTensorShape shape, DataType
+         dtype, const Variable::Attrs& attrs);
+  operator ::tensorflow::Output() const { return ref; }
+  operator ::tensorflow::Input() const { return ref; }
+  ::tensorflow::Node* node() const { return ref.node(); }
+
+  static Attrs Container(StringPiece x) {
+    return Attrs().Container(x);
+  }
+  static Attrs SharedName(StringPiece x) {
+    return Attrs().SharedName(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output ref;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_STATE_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/state_ops_internal.h

@@ -0,0 +1,132 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_STATE_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_STATE_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup state_ops_internal State Ops Internal
+/// @{
+
+/// Computes element-wise maximum.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A mutable Tensor. Should be from a Variable node.
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Same as ref. Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterNdMax {
+ public:
+  /// Optional attribute setters for ScatterNdMax
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterNdMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterNdMax(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates, const
+             ScatterNdMax::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+/// Computes element-wise minimum.
+///
+/// Args:
+/// * scope: A Scope object
+/// * ref: A mutable Tensor. Should be from a Variable node.
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Same as ref. Returned as a convenience for operations that want
+/// to use the updated values after the update is done.
+class ScatterNdMin {
+ public:
+  /// Optional attribute setters for ScatterNdMin
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ScatterNdMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates);
+  ScatterNdMin(const ::tensorflow::Scope& scope, ::tensorflow::Input ref,
+             ::tensorflow::Input indices, ::tensorflow::Input updates, const
+             ScatterNdMin::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output_ref; }
+  operator ::tensorflow::Input() const { return output_ref; }
+  ::tensorflow::Node* node() const { return output_ref.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output_ref;
+};
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_STATE_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/string_ops.h

@@ -0,0 +1,1284 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_STRING_OPS_H_
+#define TENSORFLOW_CC_OPS_STRING_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup string_ops String Ops
+/// @{
+
+/// Converts each entry in the given tensor to strings.
+///
+/// Supports many numeric types and boolean.
+///
+/// For Unicode, see the
+/// [https://www.tensorflow.org/tutorials/representation/unicode](Working with Unicode text)
+/// tutorial.
+///
+/// Examples:
+///
+/// >>> tf.strings.as_string([3, 2])
+/// <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'3', b'2'], dtype=object)>
+/// >>> tf.strings.as_string([3.1415926, 2.71828], precision=2).numpy()
+/// array([b'3.14', b'2.72'], dtype=object)
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class AsString {
+ public:
+  /// Optional attribute setters for AsString
+  struct Attrs {
+    /// The post-decimal precision to use for floating point numbers.
+    /// Only used if precision > -1.
+    ///
+    /// Defaults to -1
+    TF_MUST_USE_RESULT Attrs Precision(int64 x) {
+      Attrs ret = *this;
+      ret.precision_ = x;
+      return ret;
+    }
+
+    /// Use scientific notation for floating point numbers.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs Scientific(bool x) {
+      Attrs ret = *this;
+      ret.scientific_ = x;
+      return ret;
+    }
+
+    /// Use shortest representation (either scientific or standard) for
+    /// floating point numbers.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs Shortest(bool x) {
+      Attrs ret = *this;
+      ret.shortest_ = x;
+      return ret;
+    }
+
+    /// Pad pre-decimal numbers to this width.
+    /// Applies to both floating point and integer numbers.
+    /// Only used if width > -1.
+    ///
+    /// Defaults to -1
+    TF_MUST_USE_RESULT Attrs Width(int64 x) {
+      Attrs ret = *this;
+      ret.width_ = x;
+      return ret;
+    }
+
+    /// The value to pad if width > -1.  If empty, pads with spaces.
+    /// Another typical value is '0'.  String cannot be longer than 1 character.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Fill(StringPiece x) {
+      Attrs ret = *this;
+      ret.fill_ = x;
+      return ret;
+    }
+
+    int64 precision_ = -1;
+    bool scientific_ = false;
+    bool shortest_ = false;
+    int64 width_ = -1;
+    StringPiece fill_ = "";
+  };
+  AsString(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  AsString(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
+         AsString::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Precision(int64 x) {
+    return Attrs().Precision(x);
+  }
+  static Attrs Scientific(bool x) {
+    return Attrs().Scientific(x);
+  }
+  static Attrs Shortest(bool x) {
+    return Attrs().Shortest(x);
+  }
+  static Attrs Width(int64 x) {
+    return Attrs().Width(x);
+  }
+  static Attrs Fill(StringPiece x) {
+    return Attrs().Fill(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Decode web-safe base64-encoded strings.
+///
+/// Input may or may not have padding at the end. See
+/// [EncodeBase64](https://www.tensorflow.org/api_docs/python/tf/io/encode_base64)
+/// for padding. Web-safe means that input must use - and _ instead of + and /.
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: Base64 strings to decode.
+///
+/// Returns:
+/// * `Output`: Decoded strings.
+class DecodeBase64 {
+ public:
+  DecodeBase64(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Encode strings into web-safe base64 format.
+///
+/// Refer to [this article](https://en.wikipedia.org/wiki/Base64) for more information on
+/// base64 format. 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 /.
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: Strings to be encoded.
+///
+/// Optional attributes (see `Attrs`):
+/// * pad: Bool whether padding is applied at the ends.
+///
+/// Returns:
+/// * `Output`: Input strings encoded in base64.
+class EncodeBase64 {
+ public:
+  /// Optional attribute setters for EncodeBase64
+  struct Attrs {
+    /// Bool whether padding is applied at the ends.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs Pad(bool x) {
+      Attrs ret = *this;
+      ret.pad_ = x;
+      return ret;
+    }
+
+    bool pad_ = false;
+  };
+  EncodeBase64(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  EncodeBase64(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
+             EncodeBase64::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Pad(bool x) {
+    return Attrs().Pad(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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"
+/// ```
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * keep_dims: If `True`, retain reduced dimensions with length `1`.
+/// * separator: The separator to use when joining.
+///
+/// Returns:
+/// * `Output`: Has shape equal to that of the input with reduced dimensions removed or
+/// set to `1` depending on `keep_dims`.
+class ReduceJoin {
+ public:
+  /// Optional attribute setters for ReduceJoin
+  struct Attrs {
+    /// If `True`, retain reduced dimensions with length `1`.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs KeepDims(bool x) {
+      Attrs ret = *this;
+      ret.keep_dims_ = x;
+      return ret;
+    }
+
+    /// The separator to use when joining.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Separator(StringPiece x) {
+      Attrs ret = *this;
+      ret.separator_ = x;
+      return ret;
+    }
+
+    bool keep_dims_ = false;
+    StringPiece separator_ = "";
+  };
+  ReduceJoin(const ::tensorflow::Scope& scope, ::tensorflow::Input inputs,
+           ::tensorflow::Input reduction_indices);
+  ReduceJoin(const ::tensorflow::Scope& scope, ::tensorflow::Input inputs,
+           ::tensorflow::Input reduction_indices, const ReduceJoin::Attrs&
+           attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs KeepDims(bool x) {
+    return Attrs().KeepDims(x);
+  }
+  static Attrs Separator(StringPiece x) {
+    return Attrs().Separator(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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)
+///
+/// Examples:
+///
+/// >>> tf.strings.regex_full_match(["TF lib", "lib TF"], ".*lib$")
+/// <tf.Tensor: shape=(2,), dtype=bool, numpy=array([ True, False])>
+/// >>> tf.strings.regex_full_match(["TF lib", "lib TF"], ".*TF$")
+/// <tf.Tensor: shape=(2,), dtype=bool, numpy=array([False,  True])>
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: A string tensor of the text to be processed.
+/// * pattern: A scalar string tensor containing the regular expression to match the input.
+///
+/// Returns:
+/// * `Output`: A bool tensor with the same shape as `input`.
+class RegexFullMatch {
+ public:
+  RegexFullMatch(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+               ::tensorflow::Input pattern);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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)
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: The text after applying pattern match and rewrite substitution.
+class RegexReplace {
+ public:
+  /// Optional attribute setters for RegexReplace
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs ReplaceGlobal(bool x) {
+      Attrs ret = *this;
+      ret.replace_global_ = x;
+      return ret;
+    }
+
+    bool replace_global_ = true;
+  };
+  RegexReplace(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+             ::tensorflow::Input pattern, ::tensorflow::Input rewrite);
+  RegexReplace(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+             ::tensorflow::Input pattern, ::tensorflow::Input rewrite, const
+             RegexReplace::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs ReplaceGlobal(bool x) {
+    return Attrs().ReplaceGlobal(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Formats a string template using a list of tensors.
+///
+/// Formats a string template using a list of tensors, pretty-printing tensor summaries.
+///
+/// Args:
+/// * scope: A Scope object
+/// * inputs: The list of tensors to format into the placeholder string.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: = The resulting string scalar.
+class StringFormat {
+ public:
+  /// Optional attribute setters for StringFormat
+  struct Attrs {
+    /// A string, the template to format tensor summaries into.
+    ///
+    /// Defaults to "%s"
+    TF_MUST_USE_RESULT Attrs Template(StringPiece x) {
+      Attrs ret = *this;
+      ret.template_ = x;
+      return ret;
+    }
+
+    /// A string, at each placeholder in the template a subsequent tensor summary will be inserted.
+    ///
+    /// Defaults to "%s"
+    TF_MUST_USE_RESULT Attrs Placeholder(StringPiece x) {
+      Attrs ret = *this;
+      ret.placeholder_ = x;
+      return ret;
+    }
+
+    /// When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
+    ///
+    /// Defaults to 3
+    TF_MUST_USE_RESULT Attrs Summarize(int64 x) {
+      Attrs ret = *this;
+      ret.summarize_ = x;
+      return ret;
+    }
+
+    StringPiece template_ = "%s";
+    StringPiece placeholder_ = "%s";
+    int64 summarize_ = 3;
+  };
+  StringFormat(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs);
+  StringFormat(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs,
+             const StringFormat::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Template(StringPiece x) {
+    return Attrs().Template(x);
+  }
+  static Attrs Placeholder(StringPiece x) {
+    return Attrs().Placeholder(x);
+  }
+  static Attrs Summarize(int64 x) {
+    return Attrs().Summarize(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Joins the strings in the given list of string tensors into one tensor;
+///
+/// with the given separator (default is an empty separator).
+///
+/// Examples:
+///
+/// >>> s = ["hello", "world", "tensorflow"]
+/// >>> tf.strings.join(s, " ")
+/// <tf.Tensor: shape=(), dtype=string, numpy=b'hello world tensorflow'>
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `Attrs`):
+/// * separator: string, an optional join separator.
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class StringJoin {
+ public:
+  /// Optional attribute setters for StringJoin
+  struct Attrs {
+    /// string, an optional join separator.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Separator(StringPiece x) {
+      Attrs ret = *this;
+      ret.separator_ = x;
+      return ret;
+    }
+
+    StringPiece separator_ = "";
+  };
+  StringJoin(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs);
+  StringJoin(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs,
+           const StringJoin::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Separator(StringPiece x) {
+    return Attrs().Separator(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// String lengths of `input`.
+///
+/// Computes the length of each string given in the input tensor.
+///
+/// >>> strings = tf.constant(['Hello','TensorFlow', '\U0001F642'])
+/// >>> tf.strings.length(strings).numpy() # default counts bytes
+/// array([ 5, 10, 4], dtype=int32)
+/// >>> tf.strings.length(strings, unit="UTF8_CHAR").numpy()
+/// array([ 5, 10, 1], dtype=int32)
+///
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The strings for which to compute the length for each element.
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Integer tensor that has the same shape as `input`. The output contains the
+/// element-wise string lengths of `input`.
+class StringLength {
+ public:
+  /// Optional attribute setters for StringLength
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "BYTE"
+    TF_MUST_USE_RESULT Attrs Unit(StringPiece x) {
+      Attrs ret = *this;
+      ret.unit_ = x;
+      return ret;
+    }
+
+    StringPiece unit_ = "BYTE";
+  };
+  StringLength(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  StringLength(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
+             StringLength::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Unit(StringPiece x) {
+    return Attrs().Unit(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Converts all uppercase characters into their respective lowercase replacements.
+///
+/// Example:
+///
+/// >>> tf.strings.lower("CamelCase string and ALL CAPS")
+/// <tf.Tensor: shape=(), dtype=string, numpy=b'camelcase string and all caps'>
+///
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The input to be lower-cased.
+///
+/// Optional attributes (see `Attrs`):
+/// * encoding: Character encoding of `input`. Allowed values are '' and 'utf-8'.
+/// Value '' is interpreted as ASCII.
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class StringLower {
+ public:
+  /// Optional attribute setters for StringLower
+  struct Attrs {
+    /// Character encoding of `input`. Allowed values are '' and 'utf-8'.
+    /// Value '' is interpreted as ASCII.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Encoding(StringPiece x) {
+      Attrs ret = *this;
+      ret.encoding_ = x;
+      return ret;
+    }
+
+    StringPiece encoding_ = "";
+  };
+  StringLower(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  StringLower(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
+            StringLower::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Encoding(StringPiece x) {
+    return Attrs().Encoding(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Creates ngrams from ragged string data.
+///
+/// This op accepts a ragged tensor with 1 ragged dimension containing only
+/// strings and outputs a ragged tensor with 1 ragged dimension containing ngrams
+/// of that string, joined along the innermost axis.
+///
+/// Args:
+/// * scope: A Scope object
+/// * data: The values tensor of the ragged string tensor to make ngrams out of. Must be a
+/// 1D string tensor.
+/// * data_splits: The splits tensor of the ragged string tensor to make ngrams out of.
+/// * separator: The string to append between elements of the token. Use "" for no separator.
+/// * ngram_widths: The sizes of the ngrams to create.
+/// * left_pad: The string to use to pad the left side of the ngram sequence. Only used if
+/// pad_width != 0.
+/// * right_pad: The string to use to pad the right side of the ngram sequence. Only used if
+/// pad_width != 0.
+/// * pad_width: The number of padding elements to add to each side of each
+/// sequence. Note that padding will never be greater than 'ngram_widths'-1
+/// regardless of this value. If `pad_width=-1`, then add `max(ngram_widths)-1`
+/// elements.
+///
+/// Returns:
+/// * `Output` ngrams: The values tensor of the output ngrams ragged tensor.
+/// * `Output` ngrams_splits: The splits tensor of the output ngrams ragged tensor.
+class StringNGrams {
+ public:
+  StringNGrams(const ::tensorflow::Scope& scope, ::tensorflow::Input data,
+             ::tensorflow::Input data_splits, StringPiece separator, const
+             gtl::ArraySlice<int>& ngram_widths, StringPiece left_pad,
+             StringPiece right_pad, int64 pad_width, bool
+             preserve_short_sequences);
+
+  Operation operation;
+  ::tensorflow::Output ngrams;
+  ::tensorflow::Output ngrams_splits;
+};
+
+/// 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']
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: 1-D. Strings to split.
+/// * delimiter: 0-D. Delimiter characters (bytes), or empty string.
+///
+/// Optional attributes (see `Attrs`):
+/// * skip_empty: A `bool`. If `True`, skip the empty strings from the result.
+///
+/// Returns:
+/// * `Output` indices: A dense matrix of int64 representing the indices of the sparse tensor.
+/// * `Output` values: A vector of strings corresponding to the splited values.
+/// * `Output` 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.
+class StringSplit {
+ public:
+  /// Optional attribute setters for StringSplit
+  struct Attrs {
+    /// A `bool`. If `True`, skip the empty strings from the result.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs SkipEmpty(bool x) {
+      Attrs ret = *this;
+      ret.skip_empty_ = x;
+      return ret;
+    }
+
+    bool skip_empty_ = true;
+  };
+  StringSplit(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+            ::tensorflow::Input delimiter);
+  StringSplit(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+            ::tensorflow::Input delimiter, const StringSplit::Attrs& attrs);
+
+  static Attrs SkipEmpty(bool x) {
+    return Attrs().SkipEmpty(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output indices;
+  ::tensorflow::Output values;
+  ::tensorflow::Output shape;
+};
+
+/// 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.
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: `1-D` string `Tensor`, the strings to split.
+/// * sep: `0-D` string `Tensor`, the delimiter character.
+///
+/// Optional attributes (see `Attrs`):
+/// * maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result.
+///
+/// Returns:
+/// * `Output` indices
+/// * `Output` values
+/// * `Output` shape
+class StringSplitV2 {
+ public:
+  /// Optional attribute setters for StringSplitV2
+  struct Attrs {
+    /// An `int`. If `maxsplit > 0`, limit of the split of the result.
+    ///
+    /// Defaults to -1
+    TF_MUST_USE_RESULT Attrs Maxsplit(int64 x) {
+      Attrs ret = *this;
+      ret.maxsplit_ = x;
+      return ret;
+    }
+
+    int64 maxsplit_ = -1;
+  };
+  StringSplitV2(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+              ::tensorflow::Input sep);
+  StringSplitV2(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+              ::tensorflow::Input sep, const StringSplitV2::Attrs& attrs);
+
+  static Attrs Maxsplit(int64 x) {
+    return Attrs().Maxsplit(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output indices;
+  ::tensorflow::Output values;
+  ::tensorflow::Output shape;
+};
+
+/// Strip leading and trailing whitespaces from the Tensor.
+///
+/// Examples:
+///
+/// >>> tf.strings.strip(["\nTensorFlow", "     The python library    "]).numpy()
+/// array([b'TensorFlow', b'The python library'], dtype=object)
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: A string `Tensor` of any shape.
+///
+/// Returns:
+/// * `Output`: A string `Tensor` of the same shape as the input.
+class StringStrip {
+ public:
+  StringStrip(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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()`.
+///
+/// Args:
+/// * scope: A Scope object
+/// * num_buckets: The number of buckets.
+///
+/// Returns:
+/// * `Output`: A Tensor of the same shape as the input `string_tensor`.
+class StringToHashBucket {
+ public:
+  StringToHashBucket(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                   string_tensor, int64 num_buckets);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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`.
+///
+/// Examples:
+///
+/// >>> tf.strings.to_hash_bucket_fast(["Hello", "TensorFlow", "2.x"], 3).numpy()
+/// array([0, 2, 2])
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The strings to assign a hash bucket.
+/// * num_buckets: The number of buckets.
+///
+/// Returns:
+/// * `Output`: A Tensor of the same shape as the input `string_tensor`.
+class StringToHashBucketFast {
+ public:
+  StringToHashBucketFast(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                       input, int64 num_buckets);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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 can be used to make it difficult to find inputs with a skewed hash value
+/// distribution over buckets. This requires that the hash function is
+/// seeded by a high-entropy (random) "key" unknown to the adversary.
+///
+/// The additional robustness comes at a cost of roughly 4x higher compute
+/// time than `tf.string_to_hash_bucket_fast`.
+///
+/// Examples:
+///
+/// >>> tf.strings.to_hash_bucket_strong(["Hello", "TF"], 3, [1, 2]).numpy()
+/// array([2, 0])
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The strings to assign a hash bucket.
+/// * num_buckets: The number of buckets.
+/// * key: The key used to seed the hash function, passed as a list of two uint64
+/// elements.
+///
+/// Returns:
+/// * `Output`: A Tensor of the same shape as the input `string_tensor`.
+class StringToHashBucketStrong {
+ public:
+  StringToHashBucketStrong(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                         input, int64 num_buckets, const gtl::ArraySlice<int>&
+                         key);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Converts all lowercase characters into their respective uppercase replacements.
+///
+/// Example:
+///
+/// >>> tf.strings.upper("CamelCase string and ALL CAPS")
+/// <tf.Tensor: shape=(), dtype=string, numpy=b'CAMELCASE STRING AND ALL CAPS'>
+///
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The input to be upper-cased.
+///
+/// Optional attributes (see `Attrs`):
+/// * encoding: Character encoding of `input`. Allowed values are '' and 'utf-8'.
+/// Value '' is interpreted as ASCII.
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class StringUpper {
+ public:
+  /// Optional attribute setters for StringUpper
+  struct Attrs {
+    /// Character encoding of `input`. Allowed values are '' and 'utf-8'.
+    /// Value '' is interpreted as ASCII.
+    ///
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Encoding(StringPiece x) {
+      Attrs ret = *this;
+      ret.encoding_ = x;
+      return ret;
+    }
+
+    StringPiece encoding_ = "";
+  };
+  StringUpper(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  StringUpper(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
+            StringUpper::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Encoding(StringPiece x) {
+    return Attrs().Encoding(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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, or if `len` is negative, 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']
+/// ```
+///
+/// Raises:
+///
+///   * `ValueError`: If the first argument cannot be converted to a
+///      Tensor of `dtype string`.
+///   * `InvalidArgumentError`: If indices are out of range.
+///   * `ValueError`: If `pos` and `len` are not the same shape.
+///
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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
+///
+/// Optional attributes (see `Attrs`):
+/// * 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.
+///
+/// Returns:
+/// * `Output`: Tensor of substrings
+class Substr {
+ public:
+  /// Optional attribute setters for Substr
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "BYTE"
+    TF_MUST_USE_RESULT Attrs Unit(StringPiece x) {
+      Attrs ret = *this;
+      ret.unit_ = x;
+      return ret;
+    }
+
+    StringPiece unit_ = "BYTE";
+  };
+  Substr(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+       ::tensorflow::Input pos, ::tensorflow::Input len);
+  Substr(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+       ::tensorflow::Input pos, ::tensorflow::Input len, const Substr::Attrs&
+       attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Unit(StringPiece x) {
+    return Attrs().Unit(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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
+/// [ICU project docs](http://icu-project.org/apiref/icu4c/uscript_8h.html)
+/// for more details on script codes.
+///
+/// For an example, see the unicode strings guide on [unicode scripts]
+/// (https://www.tensorflow.org/tutorials/load_data/unicode#representing_unicode).
+///
+/// Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will
+/// match input shape.
+///
+/// Examples:
+///
+/// >>> tf.strings.unicode_script([1, 31, 38])
+/// <tf.Tensor: shape=(3,), dtype=int32, numpy=array([0, 0, 0], dtype=int32)>
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: A Tensor of int32 Unicode code points.
+///
+/// Returns:
+/// * `Output`: A Tensor of int32 script codes corresponding to each input code point.
+class UnicodeScript {
+ public:
+  UnicodeScript(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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.
+///
+/// Examples:
+///
+/// >>> tf.strings.unicode_transcode(["Hello", "TensorFlow", "2.x"], "UTF-8", "UTF-16-BE")
+/// <tf.Tensor: shape=(3,), dtype=string, numpy=
+/// array([b'\x00H\x00e\x00l\x00l\x00o',
+///        b'\x00T\x00e\x00n\x00s\x00o\x00r\x00F\x00l\x00o\x00w',
+///        b'\x002\x00.\x00x'], dtype=object)>
+/// >>> tf.strings.unicode_transcode(["A", "B", "C"], "US ASCII", "UTF-8").numpy()
+/// array([b'A', b'B', b'C'], dtype=object)
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The text to be processed. Can have any shape.
+/// * 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.
+///
+/// Optional attributes (see `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.
+/// * 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.
+///
+/// Returns:
+/// * `Output`: A string tensor containing unicode text encoded using `output_encoding`.
+class UnicodeTranscode {
+ public:
+  /// Optional attribute setters for UnicodeTranscode
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "replace"
+    TF_MUST_USE_RESULT Attrs Errors(StringPiece x) {
+      Attrs ret = *this;
+      ret.errors_ = x;
+      return ret;
+    }
+
+    /// 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.
+    ///
+    /// Defaults to 65533
+    TF_MUST_USE_RESULT Attrs ReplacementChar(int64 x) {
+      Attrs ret = *this;
+      ret.replacement_char_ = x;
+      return ret;
+    }
+
+    /// Whether to replace the C0 control characters (00-1F) with the
+    /// `replacement_char`. Default is false.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs ReplaceControlCharacters(bool x) {
+      Attrs ret = *this;
+      ret.replace_control_characters_ = x;
+      return ret;
+    }
+
+    StringPiece errors_ = "replace";
+    int64 replacement_char_ = 65533;
+    bool replace_control_characters_ = false;
+  };
+  UnicodeTranscode(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+                 StringPiece input_encoding, StringPiece output_encoding);
+  UnicodeTranscode(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+                 StringPiece input_encoding, StringPiece output_encoding, const
+                 UnicodeTranscode::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Errors(StringPiece x) {
+    return Attrs().Errors(x);
+  }
+  static Attrs ReplacementChar(int64 x) {
+    return Attrs().ReplacementChar(x);
+  }
+  static Attrs ReplaceControlCharacters(bool x) {
+    return Attrs().ReplaceControlCharacters(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_STRING_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/string_ops_internal.h

@@ -0,0 +1,483 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_STRING_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_STRING_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup string_ops_internal String Ops Internal
+/// @{
+
+/// 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)
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: A string tensor of the text to be processed.
+/// * pattern: The regular expression to match the input.
+///
+/// Returns:
+/// * `Output`: A bool tensor with the same shape as `input`.
+class StaticRegexFullMatch {
+ public:
+  StaticRegexFullMatch(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                     input, StringPiece pattern);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// Replaces the match of pattern in input with rewrite.
+///
+/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The text to be processed.
+/// * pattern: The regular expression to match the input.
+/// * rewrite: The rewrite to be applied to the matched expression.
+///
+/// Optional attributes (see `Attrs`):
+/// * replace_global: If True, the replacement is global, otherwise the replacement
+/// is done only on the first match.
+///
+/// Returns:
+/// * `Output`: The text after applying pattern and rewrite.
+class StaticRegexReplace {
+ public:
+  /// Optional attribute setters for StaticRegexReplace
+  struct Attrs {
+    /// If True, the replacement is global, otherwise the replacement
+    /// is done only on the first match.
+    ///
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs ReplaceGlobal(bool x) {
+      Attrs ret = *this;
+      ret.replace_global_ = x;
+      return ret;
+    }
+
+    bool replace_global_ = true;
+  };
+  StaticRegexReplace(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+                   StringPiece pattern, StringPiece rewrite);
+  StaticRegexReplace(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+                   StringPiece pattern, StringPiece rewrite, const
+                   StaticRegexReplace::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs ReplaceGlobal(bool x) {
+    return Attrs().ReplaceGlobal(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// 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).
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The text to be decoded. Can have any shape. Note that the output is flattened
+/// to a vector of char values.
+/// * 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"`.
+///
+/// Optional attributes (see `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.
+/// * 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.
+///
+/// Returns:
+/// * `Output` row_splits: A 1D int32 tensor containing the row splits.
+/// * `Output` char_values: A 1D int32 Tensor containing the decoded codepoints.
+class UnicodeDecode {
+ public:
+  /// Optional attribute setters for UnicodeDecode
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "replace"
+    TF_MUST_USE_RESULT Attrs Errors(StringPiece x) {
+      Attrs ret = *this;
+      ret.errors_ = x;
+      return ret;
+    }
+
+    /// 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.)
+    ///
+    /// Defaults to 65533
+    TF_MUST_USE_RESULT Attrs ReplacementChar(int64 x) {
+      Attrs ret = *this;
+      ret.replacement_char_ = x;
+      return ret;
+    }
+
+    /// Whether to replace the C0 control characters (00-1F) with the
+    /// `replacement_char`. Default is false.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs ReplaceControlCharacters(bool x) {
+      Attrs ret = *this;
+      ret.replace_control_characters_ = x;
+      return ret;
+    }
+
+    /// Defaults to DT_INT64
+    TF_MUST_USE_RESULT Attrs Tsplits(DataType x) {
+      Attrs ret = *this;
+      ret.Tsplits_ = x;
+      return ret;
+    }
+
+    StringPiece errors_ = "replace";
+    int64 replacement_char_ = 65533;
+    bool replace_control_characters_ = false;
+    DataType Tsplits_ = DT_INT64;
+  };
+  UnicodeDecode(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+              StringPiece input_encoding);
+  UnicodeDecode(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
+              StringPiece input_encoding, const UnicodeDecode::Attrs& attrs);
+
+  static Attrs Errors(StringPiece x) {
+    return Attrs().Errors(x);
+  }
+  static Attrs ReplacementChar(int64 x) {
+    return Attrs().ReplacementChar(x);
+  }
+  static Attrs ReplaceControlCharacters(bool x) {
+    return Attrs().ReplaceControlCharacters(x);
+  }
+  static Attrs Tsplits(DataType x) {
+    return Attrs().Tsplits(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output row_splits;
+  ::tensorflow::Output char_values;
+};
+
+/// 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).
+///
+/// Args:
+/// * scope: A Scope object
+/// * input: The text to be decoded. Can have any shape. Note that the output is flattened
+/// to a vector of char values.
+/// * 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"`.
+///
+/// Optional attributes (see `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.
+/// * 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.
+///
+/// Returns:
+/// * `Output` row_splits: A 1D int32 tensor containing the row splits.
+/// * `Output` char_values: A 1D int32 Tensor containing the decoded codepoints.
+/// * `Output` char_to_byte_starts: A 1D int32 Tensor containing the byte index in the input string where each
+/// character in `char_values` starts.
+class UnicodeDecodeWithOffsets {
+ public:
+  /// Optional attribute setters for UnicodeDecodeWithOffsets
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "replace"
+    TF_MUST_USE_RESULT Attrs Errors(StringPiece x) {
+      Attrs ret = *this;
+      ret.errors_ = x;
+      return ret;
+    }
+
+    /// 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.)
+    ///
+    /// Defaults to 65533
+    TF_MUST_USE_RESULT Attrs ReplacementChar(int64 x) {
+      Attrs ret = *this;
+      ret.replacement_char_ = x;
+      return ret;
+    }
+
+    /// Whether to replace the C0 control characters (00-1F) with the
+    /// `replacement_char`. Default is false.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs ReplaceControlCharacters(bool x) {
+      Attrs ret = *this;
+      ret.replace_control_characters_ = x;
+      return ret;
+    }
+
+    /// Defaults to DT_INT64
+    TF_MUST_USE_RESULT Attrs Tsplits(DataType x) {
+      Attrs ret = *this;
+      ret.Tsplits_ = x;
+      return ret;
+    }
+
+    StringPiece errors_ = "replace";
+    int64 replacement_char_ = 65533;
+    bool replace_control_characters_ = false;
+    DataType Tsplits_ = DT_INT64;
+  };
+  UnicodeDecodeWithOffsets(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                         input, StringPiece input_encoding);
+  UnicodeDecodeWithOffsets(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                         input, StringPiece input_encoding, const
+                         UnicodeDecodeWithOffsets::Attrs& attrs);
+
+  static Attrs Errors(StringPiece x) {
+    return Attrs().Errors(x);
+  }
+  static Attrs ReplacementChar(int64 x) {
+    return Attrs().ReplacementChar(x);
+  }
+  static Attrs ReplaceControlCharacters(bool x) {
+    return Attrs().ReplaceControlCharacters(x);
+  }
+  static Attrs Tsplits(DataType x) {
+    return Attrs().Tsplits(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output row_splits;
+  ::tensorflow::Output char_values;
+  ::tensorflow::Output char_to_byte_starts;
+};
+
+/// 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']
+/// ```
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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]]`.
+/// * output_encoding: Unicode encoding of the output strings. Valid encodings are: `"UTF-8",
+/// "UTF-16-BE", and "UTF-32-BE"`.
+///
+/// Optional attributes (see `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.
+/// * 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).
+///
+/// Returns:
+/// * `Output`: The 1-D Tensor of strings encoded from the provided unicode codepoints.
+class UnicodeEncode {
+ public:
+  /// Optional attribute setters for UnicodeEncode
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to "replace"
+    TF_MUST_USE_RESULT Attrs Errors(StringPiece x) {
+      Attrs ret = *this;
+      ret.errors_ = x;
+      return ret;
+    }
+
+    /// 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).
+    ///
+    /// Defaults to 65533
+    TF_MUST_USE_RESULT Attrs ReplacementChar(int64 x) {
+      Attrs ret = *this;
+      ret.replacement_char_ = x;
+      return ret;
+    }
+
+    StringPiece errors_ = "replace";
+    int64 replacement_char_ = 65533;
+  };
+  UnicodeEncode(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              input_values, ::tensorflow::Input input_splits, StringPiece
+              output_encoding);
+  UnicodeEncode(const ::tensorflow::Scope& scope, ::tensorflow::Input
+              input_values, ::tensorflow::Input input_splits, StringPiece
+              output_encoding, const UnicodeEncode::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Errors(StringPiece x) {
+    return Attrs().Errors(x);
+  }
+  static Attrs ReplacementChar(int64 x) {
+    return Attrs().ReplacementChar(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+/// TODO: add doc.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The output tensor.
+class UnsortedSegmentJoin {
+ public:
+  /// Optional attribute setters for UnsortedSegmentJoin
+  struct Attrs {
+    /// Defaults to ""
+    TF_MUST_USE_RESULT Attrs Separator(StringPiece x) {
+      Attrs ret = *this;
+      ret.separator_ = x;
+      return ret;
+    }
+
+    StringPiece separator_ = "";
+  };
+  UnsortedSegmentJoin(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    inputs, ::tensorflow::Input segment_ids,
+                    ::tensorflow::Input num_segments);
+  UnsortedSegmentJoin(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                    inputs, ::tensorflow::Input segment_ids,
+                    ::tensorflow::Input num_segments, const
+                    UnsortedSegmentJoin::Attrs& attrs);
+  operator ::tensorflow::Output() const { return output; }
+  operator ::tensorflow::Input() const { return output; }
+  ::tensorflow::Node* node() const { return output.node(); }
+
+  static Attrs Separator(StringPiece x) {
+    return Attrs().Separator(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output output;
+};
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_STRING_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/training_ops_internal.h

@@ -0,0 +1,426 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_TRAINING_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_TRAINING_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup training_ops_internal Training Ops Internal
+/// @{
+
+/// 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)
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: Same as "var".
+class ApplyAdaMax {
+ public:
+  /// Optional attribute setters for ApplyAdaMax
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ApplyAdaMax(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+            ::tensorflow::Input m, ::tensorflow::Input v, ::tensorflow::Input
+            beta1_power, ::tensorflow::Input lr, ::tensorflow::Input beta1,
+            ::tensorflow::Input beta2, ::tensorflow::Input epsilon,
+            ::tensorflow::Input grad);
+  ApplyAdaMax(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+            ::tensorflow::Input m, ::tensorflow::Input v, ::tensorflow::Input
+            beta1_power, ::tensorflow::Input lr, ::tensorflow::Input beta1,
+            ::tensorflow::Input beta2, ::tensorflow::Input epsilon,
+            ::tensorflow::Input grad, const ApplyAdaMax::Attrs& attrs);
+  operator ::tensorflow::Output() const { return out; }
+  operator ::tensorflow::Input() const { return out; }
+  ::tensorflow::Node* node() const { return out.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output out;
+};
+
+/// Update '*var' according to the adagrad scheme.
+///
+/// accum += grad * grad
+/// var -= lr * grad * (1 / sqrt(accum))
+///
+/// Args:
+/// * scope: A Scope object
+/// * var: Should be from a Variable().
+/// * accum: Should be from a Variable().
+/// * lr: Scaling factor. Must be a scalar.
+/// * epsilon: Constant factor. Must be a scalar.
+/// * grad: The gradient.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: Same as "var".
+class ApplyAdagradV2 {
+ public:
+  /// Optional attribute setters for ApplyAdagradV2
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UpdateSlots(bool x) {
+      Attrs ret = *this;
+      ret.update_slots_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+    bool update_slots_ = true;
+  };
+  ApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+               ::tensorflow::Input accum, ::tensorflow::Input lr,
+               ::tensorflow::Input epsilon, ::tensorflow::Input grad);
+  ApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+               ::tensorflow::Input accum, ::tensorflow::Input lr,
+               ::tensorflow::Input epsilon, ::tensorflow::Input grad, const
+               ApplyAdagradV2::Attrs& attrs);
+  operator ::tensorflow::Output() const { return out; }
+  operator ::tensorflow::Input() const { return out; }
+  ::tensorflow::Node* node() const { return out.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+  static Attrs UpdateSlots(bool x) {
+    return Attrs().UpdateSlots(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output out;
+};
+
+/// 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)
+///
+/// Args:
+/// * scope: A Scope object
+/// * 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceApplyAdaMax {
+ public:
+  /// Optional attribute setters for ResourceApplyAdaMax
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+  };
+  ResourceApplyAdaMax(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+                    ::tensorflow::Input m, ::tensorflow::Input v,
+                    ::tensorflow::Input beta1_power, ::tensorflow::Input lr,
+                    ::tensorflow::Input beta1, ::tensorflow::Input beta2,
+                    ::tensorflow::Input epsilon, ::tensorflow::Input grad);
+  ResourceApplyAdaMax(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+                    ::tensorflow::Input m, ::tensorflow::Input v,
+                    ::tensorflow::Input beta1_power, ::tensorflow::Input lr,
+                    ::tensorflow::Input beta1, ::tensorflow::Input beta2,
+                    ::tensorflow::Input epsilon, ::tensorflow::Input grad,
+                    const ResourceApplyAdaMax::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+
+  Operation operation;
+};
+
+/// Update '*var' according to the adagrad scheme.
+///
+/// accum += grad * grad
+/// var -= lr * grad * (1 / (sqrt(accum) + epsilon))
+///
+/// Args:
+/// * scope: A Scope object
+/// * var: Should be from a Variable().
+/// * accum: Should be from a Variable().
+/// * lr: Scaling factor. Must be a scalar.
+/// * epsilon: Constant factor. Must be a scalar.
+/// * grad: The gradient.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceApplyAdagradV2 {
+ public:
+  /// Optional attribute setters for ResourceApplyAdagradV2
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UpdateSlots(bool x) {
+      Attrs ret = *this;
+      ret.update_slots_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+    bool update_slots_ = true;
+  };
+  ResourceApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                       var, ::tensorflow::Input accum, ::tensorflow::Input lr,
+                       ::tensorflow::Input epsilon, ::tensorflow::Input grad);
+  ResourceApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
+                       var, ::tensorflow::Input accum, ::tensorflow::Input lr,
+                       ::tensorflow::Input epsilon, ::tensorflow::Input grad,
+                       const ResourceApplyAdagradV2::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+  static Attrs UpdateSlots(bool x) {
+    return Attrs().UpdateSlots(x);
+  }
+
+  Operation operation;
+};
+
+/// 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))
+///
+/// Args:
+/// * scope: A Scope object
+/// * var: Should be from a Variable().
+/// * accum: Should be from a Variable().
+/// * lr: Learning rate. 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * the created `Operation`
+class ResourceSparseApplyAdagradV2 {
+ public:
+  /// Optional attribute setters for ResourceSparseApplyAdagradV2
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UpdateSlots(bool x) {
+      Attrs ret = *this;
+      ret.update_slots_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+    bool update_slots_ = true;
+  };
+  ResourceSparseApplyAdagradV2(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input var, ::tensorflow::Input
+                             accum, ::tensorflow::Input lr, ::tensorflow::Input
+                             epsilon, ::tensorflow::Input grad,
+                             ::tensorflow::Input indices);
+  ResourceSparseApplyAdagradV2(const ::tensorflow::Scope& scope,
+                             ::tensorflow::Input var, ::tensorflow::Input
+                             accum, ::tensorflow::Input lr, ::tensorflow::Input
+                             epsilon, ::tensorflow::Input grad,
+                             ::tensorflow::Input indices, const
+                             ResourceSparseApplyAdagradV2::Attrs& attrs);
+  operator ::tensorflow::Operation() const { return operation; }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+  static Attrs UpdateSlots(bool x) {
+    return Attrs().UpdateSlots(x);
+  }
+
+  Operation operation;
+};
+
+/// 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))$$
+///
+/// Args:
+/// * scope: A Scope object
+/// * var: Should be from a Variable().
+/// * accum: Should be from a Variable().
+/// * lr: Learning rate. 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.
+///
+/// Optional attributes (see `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.
+///
+/// Returns:
+/// * `Output`: Same as "var".
+class SparseApplyAdagradV2 {
+ public:
+  /// Optional attribute setters for SparseApplyAdagradV2
+  struct Attrs {
+    /// 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.
+    ///
+    /// Defaults to false
+    TF_MUST_USE_RESULT Attrs UseLocking(bool x) {
+      Attrs ret = *this;
+      ret.use_locking_ = x;
+      return ret;
+    }
+
+    /// Defaults to true
+    TF_MUST_USE_RESULT Attrs UpdateSlots(bool x) {
+      Attrs ret = *this;
+      ret.update_slots_ = x;
+      return ret;
+    }
+
+    bool use_locking_ = false;
+    bool update_slots_ = true;
+  };
+  SparseApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+                     ::tensorflow::Input accum, ::tensorflow::Input lr,
+                     ::tensorflow::Input epsilon, ::tensorflow::Input grad,
+                     ::tensorflow::Input indices);
+  SparseApplyAdagradV2(const ::tensorflow::Scope& scope, ::tensorflow::Input var,
+                     ::tensorflow::Input accum, ::tensorflow::Input lr,
+                     ::tensorflow::Input epsilon, ::tensorflow::Input grad,
+                     ::tensorflow::Input indices, const
+                     SparseApplyAdagradV2::Attrs& attrs);
+  operator ::tensorflow::Output() const { return out; }
+  operator ::tensorflow::Input() const { return out; }
+  ::tensorflow::Node* node() const { return out.node(); }
+
+  static Attrs UseLocking(bool x) {
+    return Attrs().UseLocking(x);
+  }
+  static Attrs UpdateSlots(bool x) {
+    return Attrs().UpdateSlots(x);
+  }
+
+  Operation operation;
+  ::tensorflow::Output out;
+};
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_TRAINING_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/user_ops.h

@@ -0,0 +1,44 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_USER_OPS_H_
+#define TENSORFLOW_CC_OPS_USER_OPS_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+
+/// @defgroup user_ops User Ops
+/// @{
+
+/// Output a fact about factorials.
+///
+/// Args:
+/// * scope: A Scope object
+///
+/// Returns:
+/// * `Output`: The fact tensor.
+class Fact {
+ public:
+  Fact(const ::tensorflow::Scope& scope);
+  operator ::tensorflow::Output() const { return fact; }
+  operator ::tensorflow::Input() const { return fact; }
+  ::tensorflow::Node* node() const { return fact.node(); }
+
+  Operation operation;
+  ::tensorflow::Output fact;
+};
+
+/// @}
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_USER_OPS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/user_ops_internal.h

@@ -0,0 +1,28 @@
+// This file is MACHINE GENERATED! Do not edit.
+
+#ifndef TENSORFLOW_CC_OPS_USER_OPS_INTERNAL_H_
+#define TENSORFLOW_CC_OPS_USER_OPS_INTERNAL_H_
+
+// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+namespace ops {
+namespace internal {
+// NOTE: This namespace has internal TensorFlow details that
+// are not part of TensorFlow's public API.
+
+/// @defgroup user_ops_internal User Ops Internal
+/// @{
+
+}  // namespace internal
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_USER_OPS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/ops/while_loop.h

@@ -0,0 +1,77 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_OPS_WHILE_LOOP_H_
+#define TENSORFLOW_CC_OPS_WHILE_LOOP_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/cc/framework/ops.h"
+#include "tensorflow/cc/framework/scope.h"
+
+namespace tensorflow {
+namespace ops {
+
+// Function that takes cond graph inputs and returns cond graph boolean output.
+// 'output' need not be set if an error is returned.
+typedef std::function<Status(const Scope&, const std::vector<Output>& inputs,
+                             Output* output)>
+    CondGraphBuilderFn;
+
+// Function that takes body graph inputs and returns body graph outputs.
+// 'outputs' need not be populated if an error is returned.
+typedef std::function<Status(const Scope&, const std::vector<Output>& inputs,
+                             std::vector<Output>* outputs)>
+    BodyGraphBuilderFn;
+
+// Constructs a while loop.
+//
+// Arguments:
+// * scope: used to construct the while loop.
+// * inputs: the initial values of the loop variables. Must be non-empty.
+// * cond: a function that builds the condition graph of the loop. Takes the
+//     current loop variables as inputs and returns a scalar boolean Output
+//     indicating whether the loop should continue.
+// * body: a function that builds the body graph of the loop. Takes the current
+//     loop variables as inputs and returns the updated loop variables.
+// * frame_name: the frame name to use for this while loop. This should be a
+//     unique name. This will be used as a prefix for created operations.
+// * outputs: output param that returns final loop variable outputs in non-error
+//     case. Must be non-null and empty.
+// * create_while_ctx: if true, a WhileContext is created and populated for this
+//     loop. See core/graph/while_context.h for more details on
+//     WhileContexts. This is set to false for loops used as part of gradient
+//     computations, since they're part of the gradient for a loop in the
+//     forward-pass.
+//     TODO(skyewm): revisit this. Should we create WhileContexts for all loops,
+//     even if we don't need them?
+// * cond_output: if non-null, the output of the predicate is returned. This
+//     will always be a LoopCond node.
+//
+// Returns an error if the while loop could not be fully constructed.
+//
+// TODO(skyewm): clean up partially-constructed loop in error case
+// TODO(skyewm): create public interface to this method
+Status BuildWhileLoop(const Scope& scope, const std::vector<Output>& inputs,
+                      const CondGraphBuilderFn& cond,
+                      const BodyGraphBuilderFn& body, const string& frame_name,
+                      OutputList* outputs, bool create_while_ctx = true,
+                      Output* cond_output = nullptr);
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_OPS_WHILE_LOOP_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/bundle_v2.h

@@ -0,0 +1,89 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+// Helpers for loading the persistent representation of a SavedModelV2.
+// Please note that this is depended on by code that does not make use of
+// the full runtime and its dependencies should be restricted.
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_BUNDLE_V2_H_
+#define TENSORFLOW_CC_SAVED_MODEL_BUNDLE_V2_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+#include "tensorflow/core/protobuf/saved_object_graph.pb.h"
+#include "tensorflow/core/protobuf/trackable_object_graph.pb.h"
+#include "tensorflow/core/util/tensor_bundle/tensor_bundle.h"
+
+namespace tensorflow {
+
+/// Represents a version 2 SavedModel that is loaded from storage (but not yet
+/// loaded into an executable in-memory representation).
+class SavedModelV2Bundle {
+ public:
+  using RestoreObjectsCallback =
+      std::function<Status(int, const TrackableObjectGraph::TrackableObject&)>;
+
+  /// Loads persistent representations for a SavedModelV2 from the specified
+  /// export directory.
+  static Status Load(const std::string& export_dir, SavedModelV2Bundle* bundle);
+
+  /// MetaGraphDef from the loaded SavedModel.
+  MetaGraphDef& meta_graph_def() { return meta_graph_def_; }
+
+  /// SavedObjectGraph from the MetaGraphDef.
+  const SavedObjectGraph& saved_object_graph() {
+    return meta_graph_def().object_graph_def();
+  }
+
+  /// TrackableObjectGraph loaded from the variable_reader() checkpoint.
+  TrackableObjectGraph& trackable_object_graph() {
+    return trackable_object_graph_;
+  }
+
+  /// BundleReader for accessing the variables bundle.
+  BundleReader* variable_reader() { return variable_reader_.get(); }
+
+  /// The GraphDebugInfo (or nullptr if none).
+  GraphDebugInfo* debug_info() { return debug_info_.get(); }
+
+  /// Restores objects, invoking the callback with the node id in the
+  /// saved_object_graph() and the corresponding TrackableObject from the
+  /// trackable_object_graph(). The callback may use the variable_reader() but
+  /// must not modify the underlying saved_object_graph().
+  Status VisitObjectsToRestore(RestoreObjectsCallback callback);
+
+ private:
+  Status RecurseObjectsToRestore(
+      const SavedObject* saved_object, int saved_object_node_id,
+      const TrackableObjectGraph::TrackableObject* trackable_object,
+      std::string object_name,
+      absl::flat_hash_set<int>* seen_trackable_node_ids,
+      RestoreObjectsCallback callback);
+
+  MetaGraphDef meta_graph_def_;
+  TrackableObjectGraph trackable_object_graph_;
+  std::unique_ptr<BundleReader> variable_reader_;
+  std::unique_ptr<GraphDebugInfo> debug_info_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_BUNDLE_V2_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/constants.h

@@ -0,0 +1,82 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_CONSTANTS_H_
+#define TENSORFLOW_CC_SAVED_MODEL_CONSTANTS_H_
+
+namespace tensorflow {
+
+// SavedModel assets directory.
+inline constexpr char kSavedModelAssetsDirectory[] = "assets";
+
+// SavedModel assets.extra directory.
+inline constexpr char kSavedModelAssetsExtraDirectory[] = "assets.extra";
+
+// SavedModel assets key for graph collection-def.
+inline constexpr char kSavedModelAssetsKey[] = "saved_model_assets";
+
+/// SavedModel legacy init op collection key. Used in v1 SavedModels.
+inline constexpr char kSavedModelLegacyInitOpKey[] = "legacy_init_op";
+
+/// SavedModel main op collection key. Used in v1 SavedModels.
+inline constexpr char kSavedModelMainOpKey[] = "saved_model_main_op";
+
+// CollectionDef key for the SavedModel train op.
+// Not exported while export_all_saved_models is experimental.
+inline constexpr char kSavedModelTrainOpKey[] = "saved_model_train_op";
+
+// Schema version for SavedModel.
+inline constexpr int kSavedModelSchemaVersion = 1;
+
+// SavedModel proto filename prefix.
+inline constexpr char kSavedModelFilenamePrefix[] = "saved_model";
+// SavedModel proto filename.
+inline constexpr char kSavedModelFilenamePb[] = "saved_model.pb";
+
+// SavedModel chunked proto filename.
+inline constexpr char kSavedModelFilenameCpb[] = "saved_model.cpb";
+
+// SavedModel text format proto filename.
+inline constexpr char kSavedModelFilenamePbTxt[] = "saved_model.pbtxt";
+
+// Subdirectory where debugging related files are written.
+inline constexpr char kSavedModelDebugDirectory[] = "debug";
+
+// File name for GraphDebugInfo protocol buffer which corresponds to the
+// SavedModel.
+inline constexpr char kSavedModelDebugInfoFilenamePb[] =
+    "saved_model_debug_info.pb";
+
+// Directory in which to save the SavedModel variables.
+inline constexpr char kSavedModelVariablesDirectory[] = "variables";
+
+// SavedModel variables filename.
+inline constexpr char kSavedModelVariablesFilename[] = "variables";
+
+// SavedModel SignatureDef keys for the initialization and train ops. Used in
+// V2 SavedModels.
+inline constexpr char kSavedModelInitOpSignatureKey[] = "__saved_model_init_op";
+inline constexpr char kSavedModelTrainOpSignatureKey[] =
+    "__saved_model_train_op";
+
+// Key in the TensorBundle for the object graph proto.
+inline constexpr char kObjectGraphProtoKey[] = "_CHECKPOINTABLE_OBJECT_GRAPH";
+
+// Filename for the FingerprintDef protocol buffer.
+inline constexpr char kFingerprintFilenamePb[] = "fingerprint.pb";
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_CONSTANTS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/fingerprinting.h

@@ -0,0 +1,47 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_FINGERPRINTING_H_
+#define TENSORFLOW_CC_SAVED_MODEL_FINGERPRINTING_H_
+
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/protobuf/fingerprint.pb.h"
+
+namespace tensorflow::saved_model::fingerprinting {
+
+// Creates a FingerprintDef proto from a SavedModel (regular or chunked) and the
+// checkpoint meta file (.index) in `export_dir`.
+absl::StatusOr<FingerprintDef> CreateFingerprintDef(
+    absl::string_view export_dir);
+
+// Loads the `fingerprint.pb` from `export_dir`, returns an error if there is
+// none.
+absl::StatusOr<FingerprintDef> ReadSavedModelFingerprint(
+    absl::string_view export_dir);
+
+// Canonical fingerprinting ID for a SavedModel.
+std::string Singleprint(uint64_t graph_def_program_hash,
+                        uint64_t signature_def_hash,
+                        uint64_t saved_object_graph_hash,
+                        uint64_t checkpoint_hash);
+std::string Singleprint(const FingerprintDef& fingerprint);
+absl::StatusOr<std::string> Singleprint(absl::string_view export_dir);
+
+}  // namespace tensorflow::saved_model::fingerprinting
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_FINGERPRINTING_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/loader.h

@@ -0,0 +1,147 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+/// SavedModel loading functions and SavedModelBundle struct.
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_LOADER_H_
+#define TENSORFLOW_CC_SAVED_MODEL_LOADER_H_
+
+#include <string>
+#include <unordered_set>
+
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+#include "tensorflow/core/public/session.h"
+
+namespace tensorflow {
+
+/// Represents a SavedModel that is loaded from storage.
+class SavedModelBundleInterface {
+ public:
+  virtual ~SavedModelBundleInterface();
+
+  /// Returns the TensorFlow Session that can be used to interact with the
+  /// SavedModel.
+  virtual Session* GetSession() const = 0;
+
+  /// Returns a map from signature name to SignatureDef for all signatures in
+  /// in the SavedModel.
+  virtual const protobuf::Map<string, SignatureDef>& GetSignatures() const = 0;
+};
+
+/// SavedModel representation once the SavedModel is loaded from storage.
+///
+/// NOTE: Prefer to use SavedModelBundleLite in new code, as it consumes less
+/// RAM.
+struct SavedModelBundle : public SavedModelBundleInterface {
+  /// A TensorFlow Session does not Close itself on destruction. To avoid
+  /// resource leaks, we explicitly call Close on Sessions that we create.
+  ~SavedModelBundle() override {
+    if (session) {
+      session->Close().IgnoreError();
+    }
+  }
+
+  SavedModelBundle() = default;
+
+  Session* GetSession() const override { return session.get(); }
+  const protobuf::Map<string, SignatureDef>& GetSignatures() const override {
+    return meta_graph_def.signature_def();
+  }
+
+  std::unique_ptr<Session> session;
+  MetaGraphDef meta_graph_def;
+  std::unique_ptr<GraphDebugInfo> debug_info;
+};
+
+// A version of SavedModelBundle that avoids storing a potentially large
+// MetaGraphDef. Prefer to use SavedModelBundleLite in new code.
+class SavedModelBundleLite : public SavedModelBundleInterface {
+ public:
+  SavedModelBundleLite() = default;
+  SavedModelBundleLite(SavedModelBundleLite&& other) = default;
+  SavedModelBundleLite& operator=(SavedModelBundleLite&& other) = default;
+
+  SavedModelBundleLite(std::unique_ptr<Session> session,
+                       protobuf::Map<string, SignatureDef> signatures)
+      : session_(std::move(session)), signatures_(std::move(signatures)) {}
+
+  /// A TensorFlow Session does not Close itself on destruction. To avoid
+  /// resource leaks, we explicitly call Close on Sessions that we create.
+  ~SavedModelBundleLite() override {
+    if (session_) {
+      session_->Close().IgnoreError();
+    }
+  }
+
+  Session* GetSession() const override { return session_.get(); }
+  const protobuf::Map<string, SignatureDef>& GetSignatures() const override {
+    return signatures_;
+  }
+
+ private:
+  std::unique_ptr<Session> session_;
+  protobuf::Map<string, SignatureDef> signatures_;
+};
+
+// Restore variable and resources in the SavedModel export dir for the
+// indicated metagraph.
+// The recommended way to load a saved model is to call LoadSavedModel,
+// which provides an already initialized Metagraph, Session, and DebugInfo.
+Status RestoreSession(const RunOptions& run_options,
+                      const MetaGraphDef& meta_graph, const string& export_dir,
+                      std::unique_ptr<Session>* session);
+
+// Initialize a session which wraps this metagraph.
+// The recommended way to load a saved model is to call LoadSavedModel,
+// which provides an already initialized Metagraph, Session, and DebugInfo.
+Status LoadMetagraphIntoSession(const SessionOptions& session_options,
+                                const MetaGraphDef& meta_graph,
+                                std::unique_ptr<Session>* session);
+
+/// Loads a SavedModel from the specified export directory. The MetaGraphDef
+/// to be loaded is identified by the supplied tags, corresponding exactly to
+/// the set of tags used at SavedModel build time. Stores a SavedModel bundle in
+/// *bundle with a session and the requested MetaGraphDef, if found.
+///
+/// NOTE: Prefer the overload that takes a SavedModelBundleLite* in new code.
+Status LoadSavedModel(const SessionOptions& session_options,
+                      const RunOptions& run_options, const string& export_dir,
+                      const std::unordered_set<string>& tags,
+                      SavedModelBundle* const bundle);
+
+/// Loads a SavedModel from the specified export directory. The MetaGraphDef
+/// to be loaded is identified by the supplied tags, corresponding exactly to
+/// the set of tags used at SavedModel build time. Stores a SavedModel bundle
+/// in *bundle with a session created from the requested MetaGraphDef if found.
+///
+/// This overload creates a SavedModelBundleLite, which consumes less RAM than
+/// an equivalent SavedModelBundle.
+Status LoadSavedModel(const SessionOptions& session_options,
+                      const RunOptions& run_options, const string& export_dir,
+                      const std::unordered_set<string>& tags,
+                      SavedModelBundleLite* const bundle);
+
+/// Checks whether the provided directory could contain a SavedModel. Note that
+/// the method does not load any data by itself. If the method returns `false`,
+/// the export directory definitely does not contain a SavedModel. If the method
+/// returns `true`, the export directory may contain a SavedModel but provides
+/// no guarantee that it can be loaded.
+bool MaybeSavedModelDirectory(const std::string& export_dir);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_LOADER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/loader_util.h

@@ -0,0 +1,39 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_LOADER_UTIL_H_
+#define TENSORFLOW_CC_SAVED_MODEL_LOADER_UTIL_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+
+namespace tensorflow {
+namespace internal {
+
+// A SavedModel may store the name of the initialization op to run in the
+// in the SignatureDef (v2) or a collection (v1). If an init_op collection
+// exists, then the collection must contain exactly one op.
+Status GetInitOp(const string& export_dir, const MetaGraphDef& meta_graph_def,
+                 string* init_op_name);
+
+Status GetAssetFileDefs(const MetaGraphDef& meta_graph_def,
+                        std::vector<AssetFileDef>* asset_file_defs);
+
+}  // namespace internal
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_LOADER_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/metrics.h

@@ -0,0 +1,133 @@
+/* Copyright 2021 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.
+==============================================================================*/
+// APIs for accessing SavedModel and checkpoint metric objects.
+//
+// In order to collect the data from these metrics, please add the metrics to
+// the provided monitoring platform. Unless configured with a user-specified
+// monitoring platform, the data is not collected in OSS.
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_METRICS_H_
+#define TENSORFLOW_CC_SAVED_MODEL_METRICS_H_
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/lib/monitoring/counter.h"
+#include "tensorflow/core/lib/monitoring/gauge.h"
+#include "tensorflow/core/lib/monitoring/sampler.h"
+#include "tensorflow/core/protobuf/fingerprint.pb.h"
+
+namespace tensorflow {
+namespace metrics {
+
+const char kFingerprintFound[] = "FOUND";
+const char kFingerprintNotFound[] = "NOT_FOUND";
+const char kFingerprintError[] = "ERROR";
+
+// Returns "/tensorflow/core/saved_model/write/count" cell. This metric
+// has 1 field "write_version", which is equal to the
+// `tensorflow::libexport::GetWriteVersion` of the protobuf and should be
+// incremented when a SavedModel has been successfully written.
+monitoring::CounterCell& SavedModelWriteCount(absl::string_view write_version);
+
+// Returns "/tensorflow/core/saved_model/read/count" cell. This metric
+// has 1 field "write_version", which is equal to the
+// `tensorflow::libexport::GetWriteVersion` of the protobuf, and should be
+// incremented when a SavedModel has been successfully read.
+monitoring::CounterCell& SavedModelReadCount(absl::string_view write_version);
+
+// Returns "/tensorflow/core/saved_model/write/api" cell. This metric has 1
+// field "api_label" which corresponds to a SavedModel write API. The cell for
+// `foo` should be incremented when the write API `foo` is called.
+monitoring::CounterCell& SavedModelWriteApi(absl::string_view api_label);
+
+// Returns "/tensorflow/core/saved_model/read/api" cell. This metric has 1
+// field "api_label" which corresponds to a SavedModel read API. The cell for
+// `foo` should be incremented when the read API `foo` is called.
+monitoring::CounterCell& SavedModelReadApi(absl::string_view api_label);
+
+// Returns "/tensorflow/core/saved_model/write/fingerprint" cell, which contains
+// the saved_model_checksum of the SM's fingerprint when it is exported.
+monitoring::GaugeCell<std::string>& SavedModelWriteFingerprint();
+
+// Returns "/tensorflow/core/saved_model/write/path" cell, which contains
+// the saved_model_path of the SM when it is exported.
+monitoring::GaugeCell<std::string>& SavedModelWritePath();
+
+// Returns "/tensorflow/core/saved_model/write/path_and_fingerprint" cell, which
+// contains the path (saved_model_path) and fingerprint (concatenation of
+// graph_def_program_hash, signature_def_hash, saved_object_graph_hash,
+// and checkpoint_hash) of the SavedModel when it is exported.
+monitoring::GaugeCell<std::string>& SavedModelWritePathAndSingleprint();
+
+// Returns "/tensorflow/core/saved_model/read/fingerprint" cell, wich contains
+// the saved_model_checksum of the SM's fingerprint when it is imported.
+monitoring::GaugeCell<std::string>& SavedModelReadFingerprint();
+
+// Returns "/tensorflow/core/saved_model/read/path" cell, wich contains
+// the saved_model_path of the SM when it is imported.
+monitoring::GaugeCell<std::string>& SavedModelReadPath();
+
+// Returns "/tensorflow/core/saved_model/read/path_and_fingerprint" cell, which
+// contains the path (saved_model_path) and singleprint (concatenation of
+// graph_def_program_hash, signature_def_hash, saved_object_graph_hash,
+// and checkpoint_hash) of the SavedModel when it is imported.
+monitoring::GaugeCell<std::string>& SavedModelReadPathAndSingleprint();
+
+// Returns the fingerprint as a Json string.
+std::string MakeFingerprintJson(FingerprintDef fingerprint_def);
+
+// Returns canonical string concatenation of path and singleprint.
+absl::StatusOr<std::string> MakeSavedModelPathAndSingleprint(
+    std::string path, std::string singleprint);
+
+// Returns path and singleprint as a pair, parsed canonically from the string
+// metric.
+absl::StatusOr<std::pair<std::string, std::string>>
+ParseSavedModelPathAndSingleprint(std::string path_and_singleprint);
+
+// Returns string status indicating whether or not the fingerprint.pb file was
+// found when loading the SavedModel.
+monitoring::GaugeCell<std::string>& SavedModelFoundFingerprintOnLoad();
+
+// Returns "/tensorflow/core/checkpoint/read/read_durations" cell belonging to
+// field `api_label`.
+monitoring::SamplerCell& CheckpointReadDuration(absl::string_view api_label);
+
+// Returns "/tensorflow/core/checkpoint/write/write_durations" cell belonging to
+// field `api_label`.
+monitoring::SamplerCell& CheckpointWriteDuration(absl::string_view api_label);
+
+// Returns "/tensorflow/core/checkpoint/write/async_write_durations" cell
+// belonging to field `api_label`.
+monitoring::SamplerCell& AsyncCheckpointWriteDuration(
+    absl::string_view api_label);
+
+// Returns  "/tensorflow/core/checkpoint/write/training_time_saved" cell
+// belonging to field `api_label`.
+monitoring::CounterCell& TrainingTimeSaved(absl::string_view api_label);
+
+// Returns  "/tensorflow/core/checkpoint/write/checkpoint_size" cell
+// belonging to field (`api_label`, `filesize`).
+monitoring::CounterCell& CheckpointSize(absl::string_view api_label,
+                                        int64_t filesize);
+
+}  // namespace metrics
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_METRICS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/reader.h

@@ -0,0 +1,49 @@
+/* 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.
+==============================================================================*/
+
+/// Functions to read the SavedModel proto, or parts of it.
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_READER_H_
+#define TENSORFLOW_CC_SAVED_MODEL_READER_H_
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+#include "tensorflow/core/protobuf/saved_model.pb.h"
+
+namespace tensorflow {
+Status ReadSavedModel(absl::string_view export_dir,
+                      SavedModel* saved_model_proto);
+
+// Reads the SavedModel proto from saved_model.pb(txt) in the given directory,
+// finds the MetaGraphDef that matches the given set of tags and writes it to
+// the `meta_graph_def` parameter. Returns a failure status when the SavedModel
+// file does not exist or no MetaGraphDef matches the tags.
+Status ReadMetaGraphDefFromSavedModel(const string& export_dir,
+                                      const std::unordered_set<string>& tags,
+                                      MetaGraphDef* meta_graph_def);
+
+// Store debug info from the SavedModel export dir.
+Status ReadSavedModelDebugInfoIfPresent(
+    const string& export_dir,
+    std::unique_ptr<GraphDebugInfo>* debug_info_proto);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_READER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/saved_model/util.h

@@ -0,0 +1,56 @@
+/* Copyright 2021 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.
+==============================================================================*/
+#ifndef TENSORFLOW_CC_SAVED_MODEL_UTIL_H_
+#define TENSORFLOW_CC_SAVED_MODEL_UTIL_H_
+
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+#include "tensorflow/core/protobuf/saved_model.pb.h"
+
+namespace tensorflow {
+namespace saved_model {
+
+// Utility functions for SavedModel reading and writing.
+
+// Returns "WriteVersion" ("1" or "2") of the SavedModel protobuf. If the
+// protobuf has exactly one MetaGraphDef, which contains a SavedObjectGraph, it
+// is version 2. Else, the protobuf is version 1.
+//
+// NOTE: The "WriteVersion" does *not* equal the major version of TF.
+std::string GetWriteVersion(const SavedModel& saved_model);
+
+// Get view of string keys of a map.
+std::set<std::string> GetMapKeys(
+    const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& map);
+
+// Get the default input value from signature if it's missing in the request
+// inputs. If `is_alias` is set to true, the keys of the `request_inputs` are
+// alias names rather than the feed names in the graph.
+Status GetInputValues(
+    const SignatureDef& signature,
+    const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& request_inputs,
+    std::vector<std::pair<string, Tensor>>& inputs);
+
+}  // namespace saved_model
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/tools/freeze_saved_model.h

@@ -0,0 +1,43 @@
+/* Copyright 2017 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.
+==============================================================================*/
+#ifndef TENSORFLOW_CC_TOOLS_FREEZE_SAVED_MODEL_H_
+#define TENSORFLOW_CC_TOOLS_FREEZE_SAVED_MODEL_H_
+
+#include <unordered_set>
+
+#include "tensorflow/cc/saved_model/loader.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Returns a frozen GraphDef, input tensors, and output tensors from the loaded
+// SavedModelBundle.
+// `inputs` and `outputs` consist of the union of all inputs and outputs in the
+// SignatureDefs in the SavedModelBundle.
+// FreezeSavedModel sets `frozen_graph_def` to a GraphDef of all nodes needed by
+// `outputs`. All variables in the supplied SavedModelBundle are converted to
+// constants, set to the value of the variables, by running the restored Session
+// in the SavedModelBundle.
+// WARNING: Only the variable checkpoints will be reflected in the frozen
+// graph_def. All saved_model assets will be ignored.
+Status FreezeSavedModel(const SavedModelBundle& saved_model_bundle,
+                        GraphDef* frozen_graph_def,
+                        std::unordered_set<string>* inputs,
+                        std::unordered_set<string>* outputs);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_TOOLS_FREEZE_SAVED_MODEL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/training/coordinator.h

@@ -0,0 +1,132 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_TRAINING_COORDINATOR_H_
+#define TENSORFLOW_CC_TRAINING_COORDINATOR_H_
+
+#include <atomic>
+#include <memory>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/error_codes.pb.h"
+
+namespace tensorflow {
+
+/// The abstract interface for runners which must implement the Join and the
+/// IsRunning function.
+class RunnerInterface {
+ public:
+  virtual ~RunnerInterface() {}
+  virtual Status Join() = 0;
+  virtual Status ExportCostGraph(CostGraphDef* cost_graph) const {
+    return Status(absl::StatusCode::kInvalidArgument,
+                  "No cost model to export.");
+  }
+  /// Returns true iff the runner is running, i.e. if it is trying to populate
+  /// its queue.
+  virtual bool IsRunning() const = 0;
+};
+
+/// Coordinator class manages the termination of a collection of QueueRunners.
+/// Without a coordinator, QueueRunners have to be joined in a specific order;
+/// otherwise the QueueRunner::Join() could sometimes hang. The
+/// Coordinator::RequestStop() plays the key role which notifies all running
+/// threads under a coordinator to stop. This function could be called by any
+/// thread or any client.
+/// Usage, in the client:
+///   Coordinator coord;
+///   std::unique_ptr<QueueRunner> qr(&coord, ...);
+///   qr.Start(session);
+///   coord.RegisterRunner(std::move(qr));
+///   /// do some work
+///   TF_CHECK_OK(coord.Join());
+/// In each thread of QueueRunner, the coordinator needs to be used as:
+///   void Run() {
+///     while (!coord->ShouldStop()) {
+///       /// do some work
+///       if (error) {
+///         coord->RequestStop();
+///         coord->ReportStatus(error_status);
+///       }
+///     }
+///   }
+class Coordinator {
+ public:
+  Coordinator();
+
+  /// Constructor with a list of error codes which would not be taken as errors
+  /// in status reporting.
+  Coordinator(const std::vector<error::Code>& clean_stop_errors);
+
+  /// In the destructor, RequestStop() and Join() would be called.
+  ~Coordinator();
+
+  /// Registers a runner, i.e. a unit of running threads which is usually a
+  /// QueueRunner. It takes the ownership of runner to avoid lifecycle-related
+  /// problems. Note, the coordinator would not start these threads; they are
+  /// supposed to be in running state when they are registered here.
+  Status RegisterRunner(std::unique_ptr<RunnerInterface> runner);
+
+  /// Returns true iff all the registered runners have been stopped.
+  bool AllRunnersStopped();
+
+  /// Requests all running threads to stop.
+  Status RequestStop();
+
+  /// Returns true if its RequestStop() has been called.
+  bool ShouldStop();
+
+  /// Joins all threads, returns OK or the first reported and unexpected status.
+  Status Join();
+
+  /// Reports status to the coordinator. This is usually called by threads.
+  void ReportStatus(const Status& status);
+
+  /// Returns the latest status.
+  Status GetStatus();
+
+  /// Returns immediately if the coordinator is stopped or blocks until
+  /// RequestStop() is called.
+  void WaitForStop();
+
+  // Returns the cost graph from stored run metadata in registered runners.
+  Status ExportCostGraph(CostGraphDef* cost_graph) const;
+
+ private:
+  std::unordered_set<int> clean_stop_errors_;
+  condition_variable wait_for_stop_;
+
+  mutex mu_;
+  bool should_stop_ TF_GUARDED_BY(mu_);
+
+  mutex status_lock_;
+  Status status_ TF_GUARDED_BY(status_lock_);
+
+  mutable mutex runners_lock_;
+  std::vector<std::unique_ptr<RunnerInterface>> runners_
+      TF_GUARDED_BY(runners_lock_);
+
+  TF_DISALLOW_COPY_AND_ASSIGN(Coordinator);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_TRAINING_COORDINATOR_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/cc/training/queue_runner.h

@@ -0,0 +1,140 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_TRAINING_QUEUE_RUNNER_H_
+#define TENSORFLOW_CC_TRAINING_QUEUE_RUNNER_H_
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/cc/training/coordinator.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/platform/blocking_counter.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/error_codes.pb.h"
+#include "tensorflow/core/protobuf/queue_runner.pb.h"
+#include "tensorflow/core/public/session.h"
+
+namespace tensorflow {
+
+/// QueueRunner class imitates the behavior of the python version of QueueRunner
+/// which creates a thread for each enqueue op, runs close op on completion.
+class QueueRunner : public RunnerInterface {
+ public:
+  /// Creates a new QueueRunner from proto.
+  // TODO(yuefengz): we may want to initialize from queues and ops in the
+  // future.
+  static Status New(const QueueRunnerDef& queue_runner_def,
+                    std::unique_ptr<QueueRunner>* result);
+
+  /// Creates a new QueueRunner with a coordinator, see coordinator.h for usage.
+  static Status New(const QueueRunnerDef& queue_runner_def, Coordinator* coord,
+                    std::unique_ptr<QueueRunner>* result);
+
+  /// Adds a callback that the queue runner will call when it detects an error.
+  void AddErrorCallback(const std::function<void(Status)>& cb);
+
+  /// Delete the previously registered callbacks.
+  void ClearErrorCallbacks();
+
+  /// The destructor would join all the threads.
+  ~QueueRunner();
+
+  /// Starts the queue runner with the given session.
+  Status Start(Session* sess);
+
+  /// Starts the queue runner with the given session and sets the run arguments
+  /// for sess->Run. It also collects and stores the cost model.
+  Status StartAndCollectCostGraph(Session* sess,
+                                  const RunOptions& run_options = RunOptions());
+
+  /// Starts the queue runner with the given session, and wait for up to the
+  /// specified time (in milliseconds) for the queues to start to fill up.
+  Status Start(Session* sess, int wait_for_ms);
+  Status StartAndCollectCostGraph(Session* session, int wait_for_ms,
+                                  const RunOptions& run_options = RunOptions());
+
+  /// Requests to stop and runs the cancel op. It would be called in a separate
+  /// thread when coordinator is set. If there is no coordinator it should be
+  /// called before calling Join.
+  void Stop(Session* sess);
+
+  /// Joins all the threads. Returns okay if all threads run successfully;
+  /// otherwise returns the first captured failure status.
+  Status Join() final;
+
+  /// Returns the latest status.
+  Status GetStatus();
+
+  // Returns the stored cost model.
+  Status ExportCostGraph(CostGraphDef* cost_graph) const override;
+
+ private:
+  QueueRunner() : coord_(nullptr), stopped_(false), cg_mu_(nullptr) {}
+
+  // Initializes the instance with the QueueRunnerDef proto.
+  Status Init(const QueueRunnerDef& queue_runner_def);
+
+  // The Run function for each thread.
+  void Run(Session* sess, const string& enqueue_op);
+
+  // Updates the internal status; it only keeps OK or the first unexpected error
+  // status.
+  void UpdateStatus(const Status& status);
+
+  bool IsQueueClosed(Status status) const {
+    return queue_closed_exception_types_.count(
+               static_cast<int>(status.code())) > 0;
+  }
+
+  bool IsRunning() const override { return !stopped_; }
+
+  void SetRunArgumentsAndCostGraph(const RunOptions& run_options);
+
+  Status RealRun(Session* sess, const string& op, bool update_costs);
+
+  string queue_name_;
+  std::vector<string> enqueue_op_names_;
+  string close_op_name_;
+  string cancel_op_name_;
+  // code::Code casted to int to avoid a hash function.
+  std::unordered_set<int> queue_closed_exception_types_;
+
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+  mutex mu_;
+  int runs_ = 0;
+  Status status_ TF_GUARDED_BY(mu_);
+  Status enqueue_status_ TF_GUARDED_BY(mu_);
+  std::unique_ptr<BlockingCounter> counter_;
+
+  Coordinator* coord_;
+
+  std::atomic<bool> stopped_;
+
+  mutex cb_mu_;
+  std::vector<std::function<void(Status)>> callbacks_;
+
+  mutable std::unique_ptr<mutex> cg_mu_;
+  std::unique_ptr<CostGraphDef> cost_graph_ TF_GUARDED_BY(cg_mu_);
+  RunOptions run_options_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_TRAINING_QUEUE_RUNNER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/build_xla_ops_pass.h

@@ -0,0 +1,45 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_BUILD_XLA_OPS_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_BUILD_XLA_OPS_PASS_H_
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Replaces TF function calls marked with `_XlaCompiledKernel` with _XlaCompile
+// and _XlaRun nodes (which compile and launch, respectively, the corresponding
+// HLO module).
+class BuildXlaOpsPass : public GraphOptimizationPass {
+ public:
+  // If enable_lazy_compilation is not nullopt then *enable_lazy_compilation
+  // overrides --tf_xla_enable_lazy_compilation flag in deciding whether lazy
+  // compilation is enabled.
+  explicit BuildXlaOpsPass(
+      std::optional<bool> enable_lazy_compilation = std::nullopt)
+      : enable_lazy_compilation_(enable_lazy_compilation) {}
+
+  Status Run(const GraphOptimizationPassOptions& options) override;
+
+ private:
+  std::optional<bool> enable_lazy_compilation_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_BUILD_XLA_OPS_PASS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/clone_constants_for_better_clustering.h

@@ -0,0 +1,62 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_CLONE_CONSTANTS_FOR_BETTER_CLUSTERING_H_
+#define TENSORFLOW_COMPILER_JIT_CLONE_CONSTANTS_FOR_BETTER_CLUSTERING_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+
+namespace tensorflow {
+// Clones small host constants in the graph to make it easier to form larger
+// clusters.
+//
+// This helps us in two ways:
+//
+//  - It reduces dependencies between clusters.  Let's say a constant C is used
+//    by nodes X and Y.  If X and Y are put in different clusters (for whatever
+//    reason) Y's cluster now has to wait for all the operations in X's cluster
+//    to finish before it starts running.
+//
+//  - It lets us create bigger clusters in multi-GPU benchmarks.  Consider the
+//    following graph:
+//
+//    digraph {
+//      Const -> GPU_1
+//      Const -> GPU_0_Y
+//      GPU_0_X -> GPU_0_Y
+//    }
+//
+//    We'd cluster Const and GPU_1 together (and place it on GPU_1), and this
+//    will block us from clustering GPU_0_X and GPU_0_Y together since that
+//    would increase the amount of work on GPU 0 waiting on work on GPU 1.
+//    However, cloning Const into two copies, one for GPU_0_Y and one for GPU_1
+//    will let us create one cluster containing {Const/copy_0, GPU_1} and
+//    another containing {Const/copy_1, GPU_0_X, GPU_0_Y}.
+//
+// We only clone small host constants now to avoid increasing memory consumption
+// too much.  Moreover, in practice the constants we have to duplicate are
+// things like the `perm` input to `Transpose` and the `size` input to `Slice`
+// which tend to be small anyway.
+
+class CloneConstantsForBetterClusteringPass : public GraphOptimizationPass {
+ public:
+  CloneConstantsForBetterClusteringPass() = default;
+
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_CLONE_CONSTANTS_FOR_BETTER_CLUSTERING_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/cluster_scoping_pass.h

@@ -0,0 +1,38 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_CLUSTER_SCOPING_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_CLUSTER_SCOPING_PASS_H_
+
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+
+namespace tensorflow {
+
+// This pass adds scopes to nodes in the _XlaInternalScope attribute to guide
+// the later clustering passes.  A major reason to do this is to prevent the
+// clustering from losing critical parallelism in the Tensorflow graph, which
+// can incur great performance degradation.
+//
+// This pass must be run before MarkForCompilationPass, as it stores the
+// scoping information that MarkForCompilationPass will need to respect for
+// clustering decision.
+class ClusterScopingPass : public GraphOptimizationPass {
+ public:
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_CLUSTER_SCOPING_PASS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/compilability_check_util.h

@@ -0,0 +1,338 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_COMPILABILITY_CHECK_UTIL_H_
+#define TENSORFLOW_COMPILER_JIT_COMPILABILITY_CHECK_UTIL_H_
+
+#include <string>
+
+#include "absl/algorithm/container.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "tensorflow/compiler/jit/defs.h"
+#include "tensorflow/compiler/jit/device_util.h"
+#include "tensorflow/compiler/jit/flags.h"
+#include "tensorflow/compiler/jit/resource_operation_safety_analysis.h"
+#include "tensorflow/compiler/tf2xla/const_analysis.h"
+#include "tensorflow/compiler/tf2xla/resource_operation_table.h"
+#include "tensorflow/compiler/tf2xla/xla_op_registry.h"
+#include "xla/service/graphcycles/graphcycles.h"
+#include "xla/statusor.h"
+#include "xla/union_find.h"
+#include "xla/util.h"
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/common_runtime/graph_constructor.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph_def_util.h"
+#include "tensorflow/core/framework/memory_types.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/graph/algorithm.h"
+#include "tensorflow/core/graph/control_flow.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/gtl/cleanup.h"
+#include "tensorflow/core/lib/strings/stringprintf.h"
+#include "tensorflow/core/public/version.h"
+#include "tensorflow/core/util/dump_graph.h"
+
+namespace tensorflow {
+// Checks whether a TF node can be compiled or not.  "Recursive" as in for call
+// and functional while nodes it recursively checks whether the callee functions
+// can be compiled.
+class RecursiveCompilabilityChecker {
+ public:
+  // Contains node name and function name. If the node is not inside a function
+  // body, function name is an empty string.
+  struct StackFrame {
+    std::string name;
+    std::string function_name;
+    std::shared_ptr<AbstractStackTrace> stack_trace;
+  };
+
+  // Contains information about uncompilable node inside a function body.
+  struct UncompilableNodeInfo {
+    std::string name;
+    // A list representing a stacktrace from the highest level node in
+    // increasing call depth to immediate node that fails the
+    // compilability checker.
+    std::vector<StackFrame> stack_trace;
+    std::string uncompilable_reason;
+  };
+
+  // Aggregates information about what kinds of ops are allowed.
+  struct OperationFilter {  // TODO(lzr): Add AllowEverything() helper.
+    // Whether resource variable ops are allowed are allowed in callees.  We do
+    // not allow resource variable ops in called functions (either as direct TF
+    // calls or as higher order control flow ops) because we do not yet model
+    // their memory effects in jit/resource_operation_safety_analysis.
+    bool allow_resource_ops_in_called_functions = false;
+
+    // Whether Stack operations are allowed.  We avoid auto-clustering Stack
+    // operations in general because we do not support snapshotting them.
+    //
+    // TODO(b/112837194): This restriction can be lifted with some work.
+    bool allow_stack_ops = false;
+
+    // Whether TensorArray operations are allowed.  We avoid auto-clustering
+    // TensorArray operations in general because we do not support snapshotting
+    // them.
+    //
+    // TODO(b/112837194): This restriction can be lifted with some work.
+    bool allow_tensor_array_ops = false;
+
+    // Whether stateful RNG ops are allowed.  XLA's RNG does not have the same
+    // seeding behavior as TensorFlow's RNG (b/34749654).  So we avoid
+    // auto-clustering stateful RNG ops.
+    bool allow_stateful_rng_ops = false;
+
+    // TODO(b/118970344): Whether ControlTrigger ops are allowed.  It is unsound
+    // to cluster ControlTrigger because of how we use deadness analysis.
+    bool allow_control_trigger = false;
+
+    // Whether it is okay to "cluster" Assert and CheckNumerics by simply
+    // removing them (they're not removed during clustering, but their
+    // XlaOpKernel is a no-op kernel).  We avoid auto-clustering these ops so
+    // that the user is not surprised when XLA is implicitly enabled. If the
+    // user explicitly specifies to use XLA, it is fine to resort to a dummy
+    // implementation. Currently Assert and CheckNumerics ops have dummy XLA
+    // implementations.
+    bool allow_eliding_assert_and_checknumerics_ops = false;
+
+    // Whether ops that produce or consume DT_VARIANT values are allowed.  We
+    // don't auto-cluster these ops because we don't yet support live-in or
+    // live-out DT_VARIANT values.
+    bool allow_ops_producing_or_consuming_variant = false;
+
+    // Whether ops known to be slow on XLA-GPU should be considered compilable.
+    bool allow_slow_ops = false;
+
+    // Whether ops known to have numerical accuracy issues should be considered
+    // compilable..
+    bool allow_inaccurate_ops = false;
+
+    // Require the function to be always compilable, regardless whether some
+    // control flow branches might be dead for a given input.
+    bool require_always_compilable = false;
+
+    // Whether string constants are compilable.
+    bool allow_string_consts = true;
+
+    // Whether to allow the compilation of CollectiveReduceV2Op.
+    bool allow_collective_reduce_v2 = true;
+
+    // Whether to allow the compilation of WhereOp.
+    bool allow_where_op = true;
+
+    // Whether to allow the compilation of UniqueOp. Compilation of the UniqueOp
+    // generates output with bounded dynamic shape that may cause failures with
+    // auto clustering.
+    // TODO(b/209813421): Enable tf.unique during
+    // autoclustering once all failures are rfixed.
+    bool allow_unique_op = true;
+
+    // Whether ops that are marked as outside compiled are always considered
+    // compilable.
+    // TODO(b/191502757):  Make this behavior true by default and remove this
+    // option once inference converter supports outside compilation.
+    bool allow_outside_compiled = false;
+  };
+
+  RecursiveCompilabilityChecker(OperationFilter op_filter,
+                                DeviceType jit_device_type)
+      : op_filter_(std::move(op_filter)),
+        jit_device_type_(std::move(jit_device_type)) {}
+
+  using UncompilableNodesMap =
+      std::map<std::string,
+               std::pair<NameAttrList, std::vector<UncompilableNodeInfo>>>;
+
+  // Returns a map where the key is the function identifier(short debug
+  // string) of the function encapsulating the uncompilable nodes, and the
+  // value is a pair of NameAttrList of the function and a vector of
+  // uncompilable node info. When uncompilable node is not inside any
+  // function call nodes, then key is a ShortDebugString() of an empty
+  // NameAttrList.
+  //
+  // Also, when `node` is inside a function body, users can set
+  // `node_stack_trace` to provide an additional context for `node`'s
+  // placement within the outer most graph.
+  UncompilableNodesMap FindUncompilableNodes(
+      const Node& node, FunctionLibraryRuntime* lib_runtime,
+      const std::vector<StackFrame>* node_stack_trace = nullptr) const;
+
+  // Returns true if `node` can be compiled by XLA.
+  bool IsCompilableNode(const Node& node,
+                        FunctionLibraryRuntime* lib_runtime) const {
+    std::vector<StackFrameView> stack_trace;
+    stack_trace.emplace_back(StackFrameView{node.name(), ""});
+    return IsCompilableNode(node, lib_runtime, &stack_trace);
+  }
+
+  // Returns true if XLA supports this Op, but we don't want to cluster it (ie:
+  // due to performance or correctness concerns).
+  bool OpIsInaccurate(const Node& node) const;
+  bool OpIsSlow(const Node& node) const;
+
+ private:
+  struct StackFrameView {
+    absl::string_view name;
+    absl::string_view function_name;
+    std::shared_ptr<AbstractStackTrace> stack_trace;
+  };
+
+  bool IsCompilableNode(
+      const Node& node, FunctionLibraryRuntime* lib_runtime,
+      std::vector<StackFrameView>* stack_trace,
+      NameAttrList* encapsulating_function = nullptr,
+      UncompilableNodesMap* uncompilable_nodes = nullptr) const;
+  bool IsCompilableCall(
+      const NodeDef& call_def, FunctionLibraryRuntime* lib_runtime,
+      std::vector<StackFrameView>* stack_trace,
+      NameAttrList* encapsulating_function = nullptr,
+      UncompilableNodesMap* uncompilable_nodes = nullptr) const;
+  bool IsCompilableIf(const Node& if_node, FunctionLibraryRuntime* lib_runtime,
+                      std::vector<StackFrameView>* stack_trace,
+                      NameAttrList* encapsulating_function,
+                      UncompilableNodesMap* uncompilable_nodes) const;
+  bool IsCompilableWhile(const Node& while_node,
+                         FunctionLibraryRuntime* lib_runtime,
+                         std::vector<StackFrameView>* stack_trace,
+                         NameAttrList* encapsulating_function,
+                         UncompilableNodesMap* uncompilable_nodes) const;
+
+  // Tests whether 'case_node' is compilable. Every operator in all branches
+  // must be compilable.
+  bool IsCompilableCase(const Node& case_node,
+                        FunctionLibraryRuntime* lib_runtime,
+                        std::vector<StackFrameView>* stack_trace,
+                        NameAttrList* encapsulating_function,
+                        UncompilableNodesMap* uncompilable_nodes) const;
+
+  // Returns compilability of node def retrieved from `node`'s attribute with
+  // name `attr_name`.
+  bool ExtractNodeDefAndCheckCompilability(
+      const Node& node, const std::string& attr_name,
+      const std::string& call_name, NameAttrList* encapsulating_function,
+      FunctionLibraryRuntime* lib_runtime,
+      std::vector<StackFrameView>* stack_trace,
+      UncompilableNodesMap* uncompilable_nodes) const;
+
+  bool IsStackOp(const Node& node) const {
+    const XlaResourceOpInfo* op_info =
+        GetResourceOpInfoForOp(node.type_string());
+    return op_info && op_info->resource_kind() == XlaResourceKind::kStack;
+  }
+
+  bool IsTensorArrayOp(const Node& node) const {
+    const XlaResourceOpInfo* op_info =
+        GetResourceOpInfoForOp(node.type_string());
+    return op_info && op_info->resource_kind() == XlaResourceKind::kTensorArray;
+  }
+
+  bool IsAssertOrCheckNumerics(absl::string_view op_name) const {
+    return op_name == "Assert" || op_name == "CheckNumerics";
+  }
+
+  bool IsStatefulRandomOp(absl::string_view op_name) const {
+    return op_name == "RandomUniform" || op_name == "RandomShuffle" ||
+           op_name == "RandomUniformInt" || op_name == "RandomStandardNormal" ||
+           op_name == "TruncatedNormal" || op_name == "Multinomial";
+  }
+
+  bool OpProducesOrConsumesVariant(const Node& node) const {
+    auto is_variant = [](DataType dtype) { return dtype == DT_VARIANT; };
+    return absl::c_any_of(node.input_types(), is_variant) ||
+           absl::c_any_of(node.output_types(), is_variant);
+  }
+
+  bool HasXLAKernel(const Node& node,
+                    string* uncompilable_reason = nullptr) const;
+
+  static void MaybeMarkUncompilableNode(
+      const absl::string_view reason,
+      const std::vector<StackFrameView>& stack_trace,
+      NameAttrList* encapsulating_function,
+      UncompilableNodesMap* uncompilable_nodes_map);
+
+  // Make sure we don't recurse infinitely on recursive functions.
+  const size_t kMaxRecursionDepth = 50;
+
+  const OperationFilter op_filter_;
+  const DeviceType jit_device_type_;
+};
+
+RecursiveCompilabilityChecker::OperationFilter CreateOperationFilter(
+    const XlaOpRegistry::DeviceRegistration& registration);
+
+// Given a FunctionLibraryRuntime and a `function`, returns this function's body
+// in `fbody` as well as the indices of its constant and resource arguments.
+// `fbody` is owned by `flr`.
+// `constant_arg_indices` and `resource_arg_indices` should be empty vector.
+// They are sorted in ascending order on this function's return.
+Status GetBodyAndConstantsAndResources(FunctionLibraryRuntime* flr,
+                                       const NameAttrList& function,
+                                       const FunctionBody** fbody,
+                                       std::vector<int>* constant_arg_indices,
+                                       std::vector<int>* resource_arg_indices);
+
+// Given a NodeDef `node_def` returns true iff `node_def` has kXlaCompileAttr
+// set.
+bool CanCreateXlaKernel(const NodeDef& node_def);
+
+// Returns memory types for the input.
+// `constant_arg_indices` and `resource_arg_indices` are sorted arrays of
+// indices corresponding to constant and resource arguments respectively.
+//
+// One might wonder, about the case where a compile-time constant argument
+// (which must be in host memory) is also used as an input into an op,
+// e.g. `Add`, that expects its inputs in device memory. Here is how it
+// works now.
+// First, what do we mean by "op expects an input in XYZ memory"?
+// There are two types of "ops" here: the tf2xla kernel and the HLO
+// computation it builds. The tf2xla kernel needs to retrieve the actual
+// numeric value of the compile-time constant tensors, so it really expects
+// them to be on in host memory. However, for other inputs, it refers to them
+// using xla::ComputationDataHandle, which is just a symbolic handle that
+// xla::ComputationBuilder assigns. How does this handle gets assigned for
+// constant arguments? Even constant arguments get an _Arg node in the graph
+// instantiated for Function compilation. The tf2xla kernel for constant _Arg
+// nodes takes the constant value, converts it to XlaLiteral, and feeds it
+// to xla::ComputationBuilder.ConstantLiteral, which returns the handle. This
+// constant XlaLiteral is included in the HLO graph, and subsequently, in
+// the actual executable, which is copied to the device before being
+// executed. Thus, when this executable runs, the constant is available in
+// device memory.
+tensorflow::MemoryTypeVector GetInputMemoryTypes(
+    const tensorflow::FunctionBody* fbody,
+    absl::Span<int const> constant_arg_indices,
+    absl::Span<int const> resource_arg_indices);
+
+// Returns output memory types.
+//
+// XlaLaunch kernel keeps all outputs (including constants, which it copies),
+// in device memory except for resources.
+tensorflow::MemoryTypeVector GetOutputMemoryTypes(
+    const tensorflow::FunctionBody* fbody);
+
+// Check whether graph can trigger XLA compilation.
+bool CanTriggerXlaCompilation(const GraphDef& graph);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_COMPILABILITY_CHECK_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/deadness_analysis.h

@@ -0,0 +1,99 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_H_
+#define TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_H_
+
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// This analyzes a TensorFlow graph to identify nodes which may have partially
+// dead inputs (i.e. these nodes may have some dead inputs and some alive
+// inputs).
+//
+// For example, the ADD node in the following graph
+//
+//      V0  PRED0    V1  PRED1
+//       |    |       |    |
+//       v    v       v    v
+//       SWITCH       SWITCH
+//          |            |
+//          +---+   + ---+
+//              |   |
+//              v   v
+//               ADD
+//
+// can have its inputs independently dead or alive based on the runtime values
+// of PRED0 and PRED1.
+//
+// It is tempting to call this a liveness analysis but I avoided that because
+// "liveness" already has other connotations.
+class DeadnessAnalysis {
+ public:
+  // An opaque representation of a predicate.  DeadnessPredicate
+  // instances that compare equal via operator== represent predicates
+  // that always evaluate to the same value.
+  struct DeadnessPredicate {
+   public:
+    DeadnessPredicate(const DeadnessPredicate&) = default;
+    DeadnessPredicate(DeadnessPredicate&&) = default;
+
+    DeadnessPredicate& operator=(const DeadnessPredicate&) = default;
+    DeadnessPredicate& operator=(DeadnessPredicate&&) = default;
+
+    bool operator==(const DeadnessPredicate& other) const {
+      return other.pred_ == pred_;
+    }
+
+    bool operator!=(const DeadnessPredicate& other) const {
+      return other.pred_ != pred_;
+    }
+
+   private:
+    explicit DeadnessPredicate(void* pred) : pred_(pred) {}
+
+    // This is really a Predicate*, but we don't want to expose that
+    // implementation detail to our clients.  `pred_` has pointer equality so we
+    // can just compare the pointer in operator== and operator!=.
+    void* pred_;
+
+    friend class DeadnessAnalysis;
+  };
+
+  virtual tsl::StatusOr<DeadnessPredicate> GetPredicateFor(Node* n,
+                                                           int oidx) const = 0;
+
+  // Prints out the internal state of this instance.  For debugging purposes
+  // only.
+  virtual void Print() const = 0;
+  virtual ~DeadnessAnalysis();
+
+  string DebugString(DeadnessPredicate predicate) const;
+
+  // Run the deadness analysis over `graph` and returns an error or a populated
+  // instance of DeadnessAnalysis in `result`.
+  static Status Run(const Graph& graph,
+                    std::unique_ptr<DeadnessAnalysis>* result);
+
+ protected:
+  static DeadnessPredicate MakeDeadnessPredicate(void* pred) {
+    return DeadnessPredicate(pred);
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/deadness_analysis_internal.h

@@ -0,0 +1,34 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_INTERNAL_H_
+#define TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_INTERNAL_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/graph/tensor_id.h"
+
+namespace tensorflow {
+namespace deadness_analysis_internal {
+
+// Returns a map describing the predicate each Tensor was mapped to.  For
+// testing purposes only.
+using PredicateMapTy = absl::flat_hash_map<TensorId, string, TensorId::Hasher>;
+Status ComputePredicates(const Graph& graph, PredicateMapTy* out_predicate_map,
+                         bool enable_optimistic = true);
+
+}  // namespace deadness_analysis_internal
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEADNESS_ANALYSIS_INTERNAL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/defs.h

@@ -0,0 +1,49 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+// Provides definitions needed for use of the TensorFlow XLA
+// device.
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEFS_H_
+#define TENSORFLOW_COMPILER_JIT_DEFS_H_
+
+namespace tensorflow {
+
+// Name of attribute used to tag operators for compilation with XLA
+
+// Implies must-compile semantics: either it will be compiled
+// with XLA, or an error will be thrown.
+extern const char* const kXlaMustCompileAttr;  // "_XlaMustCompile"
+
+// Implies auto-clustering: tagged nodes will be clustered and compiled with XLA
+// on a best-effort basis.
+extern const char* const kXlaCompileAttr;  // "_XlaCompile"
+
+// Implies auto-clustering within the given scope.
+extern const char* const kXlaScopeAttr;    // "_XlaScope"
+extern const char* const kXlaInternalScopeAttr;  // "_XlaInternalScope"
+
+// The id of the compiled cluster.
+extern const char* const kXlaClusterIdAttr;  // "_xla_compile_id"
+
+[[deprecated("XLA:CPU/GPU devices are deprecated")]] void
+RequestXlaDevicesCreation();
+
+[[deprecated("XLA:CPU/GPU devices are deprecated")]] bool
+XlaDevicesCreationRequired();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEFS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_compilation_cache.h

@@ -0,0 +1,257 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CACHE_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CACHE_H_
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+#include "absl/strings/str_cat.h"
+#include "tensorflow/compiler/jit/device_compilation_cluster_signature.h"
+#include "tensorflow/compiler/jit/xla_compile_util.h"
+#include "tensorflow/compiler/tf2xla/xla_compiler.h"
+#include "xla/client/local_client.h"
+#include "xla/pjrt/pjrt_client.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+namespace device_compilation_cache_internal {
+template <typename ExecutableType>
+int64_t ExecutableSize(const ExecutableType* executable) {
+  return 0;
+}
+
+template <>
+inline int64_t ExecutableSize<xla::LocalExecutable>(
+    const xla::LocalExecutable* executable) {
+  if (executable != nullptr && executable->executable() != nullptr) {
+    return executable->executable()->SizeOfGeneratedCodeInBytes();
+  }
+
+  return 0;
+}
+
+template <>
+inline int64_t ExecutableSize<xla::PjRtLoadedExecutable>(
+    const xla::PjRtLoadedExecutable* executable) {
+  if (executable != nullptr) {
+    return executable->SizeOfGeneratedCodeInBytes();
+  }
+
+  return 0;
+}
+}  // namespace device_compilation_cache_internal
+
+// Cache to store compiled HLO, executables and related metadata keyed by
+// `DeviceCompilationClusterSignature`. The cache owns the stored
+// CompilationResults and Executables.
+// Currently no cache eviction policy is implemented and the cache grows without
+// bound.
+template <typename ExecutableType>
+class DeviceCompilationCache {
+ public:
+  DeviceCompilationCache() = default;
+  ~DeviceCompilationCache() = default;
+
+  using Key = DeviceCompilationClusterSignature;
+  struct Value {
+    DeviceCompileState compile_state = DeviceCompileState::kUncompiled;
+    Status compilation_status;
+    int64_t request_count = 0;
+    const XlaCompiler::CompilationResult* compilation_result = nullptr;
+    ExecutableType* executable = nullptr;
+  };
+
+  // Returns std::nullopt if value for the supplied key is not found. If a value
+  // is found, `request_count` is incremented before returning the value.
+  std::optional<Value> Lookup(const Key& key) const;
+
+  // Inserts an empty value if value is not found and returns it. If a value is
+  // found, `request_count` is incremented before returning the value.
+  Value LookupOrCreate(const Key& key);
+
+  // Caches `compile_state`, `compilation_status`, `compilation_result` and
+  // `executable` and associates them with the provided `key`. Takes ownership
+  // of `compilation_result` and `executable`. Does not increment the
+  // corresponding `request_count`. Only arguments that are not std::nullopt are
+  // updated in the cache.
+  void Store(const Key& key, std::optional<DeviceCompileState> compile_state,
+             std::optional<Status> compilation_status,
+             std::optional<std::unique_ptr<XlaCompiler::CompilationResult>>
+                 compilation_result,
+             std::optional<std::unique_ptr<ExecutableType>> executable);
+
+  std::string DebugString() const;
+
+ private:
+  // The value associated with a cache entry.
+  struct Entry {
+    mutable mutex mu;
+
+    // The current compilation state for this entry.
+    DeviceCompileState compile_state TF_GUARDED_BY(mu) =
+        DeviceCompileState::kUncompiled;
+
+    // The number of times a compilation with this signature has been requested.
+    int64_t request_count TF_GUARDED_BY(mu) = 0;
+
+    // Did compilation succeed?
+    Status compilation_status TF_GUARDED_BY(mu);
+
+    // Output of the XlaCompiler.
+    std::unique_ptr<XlaCompiler::CompilationResult> compilation_result
+        TF_GUARDED_BY(mu);
+
+    // The XLA executable compiled from <computation>. May be null if no
+    // executable has been built.
+    std::unique_ptr<ExecutableType> executable TF_GUARDED_BY(mu);
+
+    std::string DebugString() const {
+      mutex_lock lock(mu);
+
+      int64_t executable_size =
+          device_compilation_cache_internal::ExecutableSize<ExecutableType>(
+              executable.get());
+
+      int64_t hlo_module_size = 0;
+      if (compilation_result != nullptr &&
+          compilation_result->computation != nullptr) {
+        hlo_module_size =
+            compilation_result->computation->proto().ByteSizeLong();
+      }
+
+      return absl::StrCat(
+          "{compile_state: ", compile_state, ", request_count: ", request_count,
+          ", compilation_status: ", compilation_status.ToString(),
+          ", compilation_result?: ", compilation_result != nullptr,
+          ", hlo_module_size: ", hlo_module_size, " bytes",
+          ", executable?: ", executable != nullptr,
+          ", executable_size: ", executable_size, " bytes}");
+    }
+  };
+
+  mutable mutex compile_cache_mu_;
+  absl::flat_hash_map<Key, std::unique_ptr<Entry>, Key::Hash> cache_
+      TF_GUARDED_BY(compile_cache_mu_);
+
+  TF_DISALLOW_COPY_AND_ASSIGN(DeviceCompilationCache);
+};
+
+template <typename ExecutableType>
+std::optional<typename DeviceCompilationCache<ExecutableType>::Value>
+DeviceCompilationCache<ExecutableType>::Lookup(const Key& key) const {
+  // The outer lock protects the existence of the cache entry. It does not
+  // protect the contents of the cache entry.
+  Entry* entry;
+  {
+    mutex_lock lock(compile_cache_mu_);
+    // Find cache entry.
+    auto it = cache_.find(key);
+    if (it == cache_.cend()) {
+      return std::nullopt;
+    }
+
+    entry = it->second.get();
+  }
+
+  mutex_lock lock(entry->mu);
+  Value value = {/*compile_state=*/entry->compile_state,
+                 /*compilation_status=*/entry->compilation_status,
+                 /*request_count=*/++entry->request_count,
+                 /*compilation_result=*/entry->compilation_result.get(),
+                 /*executable=*/entry->executable.get()};
+  return value;
+}
+
+template <typename ExecutableType>
+typename DeviceCompilationCache<ExecutableType>::Value
+DeviceCompilationCache<ExecutableType>::LookupOrCreate(const Key& key) {
+  // The outer lock protects the existence of the cache entry. It does not
+  // protect the contents of the cache entry.
+  Entry* entry;
+  {
+    mutex_lock lock(compile_cache_mu_);
+    // Emplace empty cache entry if not found.
+    auto it = cache_.emplace(key, std::make_unique<Entry>()).first;
+    entry = it->second.get();
+  }
+
+  mutex_lock lock(entry->mu);
+  Value value = {/*compile_state=*/entry->compile_state,
+                 /*compilation_status=*/entry->compilation_status,
+                 /*request_count=*/++entry->request_count,
+                 /*compilation_result=*/entry->compilation_result.get(),
+                 /*executable=*/entry->executable.get()};
+  return value;
+}
+
+template <typename ExecutableType>
+void DeviceCompilationCache<ExecutableType>::Store(
+    const Key& key, std::optional<DeviceCompileState> compile_state,
+    std::optional<Status> compilation_status,
+    std::optional<std::unique_ptr<XlaCompiler::CompilationResult>>
+        compilation_result,
+    std::optional<std::unique_ptr<ExecutableType>> executable) {
+  Entry* entry;
+  {
+    mutex_lock lock(compile_cache_mu_);
+    // Emplace empty cache entry if not found.
+    auto it = cache_.emplace(key, std::make_unique<Entry>()).first;
+    entry = it->second.get();
+  }
+
+  {
+    mutex_lock lock(entry->mu);
+    if (compile_state.has_value()) {
+      entry->compile_state = *compile_state;
+    }
+    if (compilation_status.has_value()) {
+      entry->compilation_status = *compilation_status;
+    }
+    if (compilation_result.has_value()) {
+      entry->compilation_result = std::move(*compilation_result);
+    }
+    if (executable.has_value()) {
+      entry->executable = std::move(*executable);
+    }
+  }
+
+  VLOG(4) << "Added/updated cache entry: key=" << key.HumanString()
+          << ", entry=" << entry->DebugString();
+}
+
+template <typename ExecutableType>
+std::string DeviceCompilationCache<ExecutableType>::DebugString() const {
+  std::string s = "DeviceCompilationCache<ExecutableType> {\n";
+  {
+    mutex_lock lock(compile_cache_mu_);
+    for (const auto& [key, entry] : cache_) {
+      absl::StrAppend(&s, key.HumanString(), " : ", entry->DebugString(),
+                      ",\n");
+    }
+  }
+  absl::StrAppend(&s, "}");
+
+  return s;
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CACHE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_compilation_cluster_signature.h

@@ -0,0 +1,56 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CLUSTER_SIGNATURE_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CLUSTER_SIGNATURE_H_
+
+#include <utility>
+#include <variant>
+
+#include "tensorflow/compiler/tf2xla/xla_compiler.h"
+
+namespace tensorflow {
+
+// Describes the types, shapes and any compile-time constant arguments
+// to a kernel. Key that uniquely identifies a compilation output.
+struct DeviceCompilationClusterSignature {
+  // Name of the cluster, built from the function name and it's attributes.
+  string name;
+
+  // List of args (either as a TensorTypeAndShape or as a Tensor value)
+  // for compile-time constant arguments to the compilation, ordered by
+  // argument number. Tensors must be in host memory.
+  using TensorTypeAndShape =
+      std::pair<DataType, absl::InlinedVector<int64_t, 4>>;
+  absl::InlinedVector<std::variant<Tensor, TensorTypeAndShape>, 8> args;
+
+  bool operator==(const DeviceCompilationClusterSignature& other) const;
+
+  struct Hash {
+    uint64 operator()(const DeviceCompilationClusterSignature& signature) const;
+  };
+
+  // Returns a human-readable description of the signature.
+  string HumanString() const;
+
+  // Builds the signature for a compilation.
+  static StatusOr<DeviceCompilationClusterSignature> Build(
+      const NameAttrList& function,
+      absl::Span<const XlaCompiler::Argument> args);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_CLUSTER_SIGNATURE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_compilation_profiler.h

@@ -0,0 +1,100 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_PROFILER_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_PROFILER_H_
+
+#include <cstdint>
+#include <string>
+
+#include "tensorflow/compiler/jit/xla_compile_util.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+
+namespace tensorflow {
+
+// Tracks statistics for device compilation and uses these to determine whether
+// the given cluster should be compiled or not.
+class DeviceCompilationProfiler : public ResourceBase {
+ public:
+  DeviceCompilationProfiler() = default;
+  ~DeviceCompilationProfiler() override;
+
+  struct ClusterCompileStats {
+    // Number of times the cluster has been (re-)compiled.
+    int64_t compile_count = 0;
+
+    // The number of times this cluster has been executed.
+    int64_t execution_count = 0;
+
+    // Cumulative time spent compiling the cluster.
+    int64_t cumulative_compile_time_us = 0;
+
+    // True if we have decided that this cluster is too dynamic (i.e. its shapes
+    // change too frequently) to profitably JIT compile.  Once a cluster is
+    // tagged megamorphic, it stays megamorphic forever.
+    bool is_megamorphic = false;
+
+    std::string DebugString() const {
+      return absl::StrCat(
+          "DeviceCompilationProfiler::ClusterCompileStats {compile_count=",
+          compile_count, ", execution_count=", execution_count,
+          ", cumulative_compile_time_us=", cumulative_compile_time_us,
+          ", is_megamorphic=", is_megamorphic, "}");
+    }
+  };
+
+  // Returns the compilation statistics for the given cluster.
+  StatusOr<ClusterCompileStats> GetCompileStats(
+      const NameAttrList& function) const;
+
+  // Determines whether the cluster should be compiled. Creates and inserts an
+  // entry into stats (also calls `RegisterExecution`) for `function` if it
+  // doesn't already exist.
+  virtual bool ShouldCompileCluster(const NameAttrList& function,
+                                    DeviceCompileMode compile_mode,
+                                    int64_t current_request_count);
+
+  // Registers a cluster execution. Increments the execution count for the given
+  // cluster and also determines whether the cluster has gone megamorphic (and
+  // sets the megamorphic bit accordingly).
+  void RegisterExecution(const NameAttrList& function);
+
+  // Registers a cluster compilation. Increments the compilation count and
+  // accumulates the compile time for the given cluster. Also broadcasts an
+  // XlaJitCompilationActivity.
+  virtual Status RegisterCompilation(const NameAttrList& function,
+                                     int64_t compile_time_us,
+                                     bool used_persistent_cache);
+
+  void IncrementOngoingAsyncCompilations();
+  void DecrementOngoingAsyncCompilations();
+  int64_t GetNumOngoingAsyncCompilations() const;
+  std::string DebugString() const override;
+
+ private:
+  mutable mutex mu_;
+
+  // Maps cluster names to compilation statistics for said cluster.
+  absl::flat_hash_map<std::string, ClusterCompileStats> cluster_compile_stats_
+      TF_GUARDED_BY(mu_);
+
+  int64_t num_ongoing_compilations_ TF_GUARDED_BY(mu_) = 0;
+
+  TF_DISALLOW_COPY_AND_ASSIGN(DeviceCompilationProfiler);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_COMPILATION_PROFILER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_compiler.h

@@ -0,0 +1,500 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_H_
+
+#include <memory>
+#include <numeric>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "absl/base/call_once.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "tensorflow/compiler/jit/device_compilation_cache.h"
+#include "tensorflow/compiler/jit/device_compilation_cluster_signature.h"
+#include "tensorflow/compiler/jit/device_compilation_profiler.h"
+#include "tensorflow/compiler/jit/device_compiler_client.h"
+#include "tensorflow/compiler/jit/device_executable_persistor.h"
+#include "tensorflow/compiler/jit/flags.h"
+#include "tensorflow/compiler/jit/tf_graph_to_hlo_compiler.h"
+#include "tensorflow/compiler/jit/xla_compile_util.h"
+#include "tensorflow/compiler/tf2xla/xla_compiler.h"
+#include "xla/client/local_client.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+// Compiles/lowers a given Tensorflow graph/function/cluster into a compiled XLA
+// compilation (HLO) using the XlaCompiler and compiles the resulting
+// XlaCompilationResult into an `ExecutableType` (eg. xla::LocalExecutable) by
+// calling `ClientType` (eg. xla::LocalClient).
+//
+// Caches the compiled XlaCompilationResult and Executable using a
+// DeviceCompilationCache. Compilation is done only when there's a cache miss.
+//
+// Uses the DeviceExecutablePersistor class for persistence and tries to load a
+// serialized executable from disk upon a request for compilation. If the
+// appropriate executable isn't found on disk, compiles the given Tensorflow
+// function/graph/cluster into an XlaCompilationResult (HLO) and
+// `ExecutableType` and tries saving/persisting the compiled HLO and executable
+// to disk.
+//
+// Since XLA computations must have static shapes, DeviceCompiler generates a
+// new XLA computation for each new set of input shapes.
+// TODO(b/255826209): De-templatize once we've moved to Device API completely.
+template <typename ExecutableType, typename ClientType>
+class DeviceCompiler : public ResourceBase {
+ public:
+  DeviceCompiler(
+      std::unique_ptr<DeviceExecutablePersistor<ExecutableType, ClientType>>
+          persistor,
+      std::unique_ptr<DeviceCompilerClient<ExecutableType, ClientType>>
+          compiler_client);
+  ~DeviceCompiler() override;
+
+  enum class CompileScope {
+    kOp,
+    kFunction,
+  };
+
+  // Compiles a function into a XlaCompiler::CompilationResult that can be used
+  // to execute an XLA Computation. Compilation results are cached. Compilation
+  // is skipped if there is a cache hit. `function` is the name of a Tensorflow
+  // function to compile. `args` is a description of the arguments to the
+  // computation.
+  //
+  // `compile_mode` controls the behavior of the compilation cache on a cache
+  // miss.  If `compile_mode` is `kLazy` then, based on some profitability
+  // heuristics, the compilation cache may decide not to compile the cluster at
+  // this time.  In this case it returns null into both `out_compilation_result`
+  // and `out_executable`.  If `compile_mode` is `kStrict` then the compilation
+  // cache always attempts the compilation on a cache miss. If compilation mode
+  // is 'kAsync' compilation of the cluster happens in the background while the
+  // fallback path executes.
+  //
+  // The result of compilation is written to `*out_compilation_result`, which
+  // must be non-null. If `out_executable` is non-null, also builds an
+  // `ExecutableType` and sets `out_executable` to point to it. The
+  // resulting executable pointer may be null if the computation has no
+  // non-constant outputs.
+  Status CompileIfNeeded(
+      const XlaCompiler::Options& options, const NameAttrList& function,
+      const std::vector<XlaCompiler::Argument>& args,
+      const XlaCompiler::CompileOptions& compile_options,
+      DeviceCompileMode compile_mode, DeviceCompilationProfiler* profiler,
+      const XlaCompiler::CompilationResult** out_compilation_result,
+      ExecutableType** out_executable);
+
+  // As above, but for a single op.
+  Status CompileSingleOpIfNeeded(
+      const XlaCompiler::Options& options,
+      const std::vector<XlaCompiler::Argument>& args,
+      const XlaCompiler::CompileOptions& compile_options, OpKernelContext* ctx,
+      DeviceCompilationProfiler* profiler,
+      const XlaCompiler::CompilationResult** out_compilation_result,
+      ExecutableType** out_executable);
+
+  ClientType* client() const { return compiler_client_->client(); }
+  const DeviceType& device_type() const { return persistor_->device_type(); }
+  DeviceCompilationCache<ExecutableType>* cache() { return cache_.get(); }
+  DeviceExecutablePersistor<ExecutableType, ClientType>* persistor() {
+    return persistor_.get();
+  }
+  DeviceCompilerClient<ExecutableType, ClientType>* compiler_client() {
+    return compiler_client_.get();
+  }
+
+  string DebugString() const override;
+
+ private:
+  // Common implementation of Compile and CompileSingleOp. The `OpKernelContext`
+  // parameter is always null for the former.
+  Status CompileImpl(
+      const XlaCompiler::CompileOptions& compile_options,
+      const XlaCompiler::Options& options, const NameAttrList& function,
+      const std::vector<XlaCompiler::Argument>& args, CompileScope scope,
+      DeviceCompileMode compile_mode, OpKernelContext* ctx,
+      DeviceCompilationProfiler* profiler,
+      const XlaCompiler::CompilationResult** out_compilation_result,
+      ExecutableType** out_executable);
+
+  StatusOr<typename DeviceCompilationCache<ExecutableType>::Value>
+  CompileStrict(
+      const DeviceCompilationClusterSignature& sig,
+      const XlaCompiler::CompileOptions& compile_options,
+      const XlaCompiler::Options& options,
+      const std::vector<XlaCompiler::Argument>& args,
+      const NameAttrList& function,
+      typename DeviceCompilationCache<ExecutableType>::Value cache_value,
+      CompileScope scope, OpKernelContext* ctx,
+      DeviceCompilationProfiler* profiler, mutex* mu)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(*mu);
+
+  Status CompileAsynchronous(const DeviceCompilationClusterSignature& sig,
+                             const XlaCompiler::CompileOptions& compile_options,
+                             const XlaCompiler::Options& options,
+                             const std::vector<XlaCompiler::Argument>& args,
+                             const NameAttrList& function, CompileScope scope,
+                             OpKernelContext* ctx,
+                             DeviceCompilationProfiler* profiler);
+
+  std::unique_ptr<DeviceExecutablePersistor<ExecutableType, ClientType>>
+      persistor_;
+  std::unique_ptr<DeviceCompilerClient<ExecutableType, ClientType>>
+      compiler_client_;
+  std::unique_ptr<DeviceCompilationCache<ExecutableType>> cache_;
+
+  // Pool of threads for asynchronous compilations.
+  std::unique_ptr<thread::ThreadPool> async_compiler_threads_;
+
+  mutex cluster_mutexes_mu_;
+  absl::flat_hash_map<DeviceCompilationClusterSignature, std::unique_ptr<mutex>,
+                      DeviceCompilationClusterSignature::Hash>
+      cluster_mutexes_ TF_GUARDED_BY(cluster_mutexes_mu_);
+
+  TF_DISALLOW_COPY_AND_ASSIGN(DeviceCompiler);
+};
+
+namespace device_compiler_internal {
+// Print something that users can search for to definitively ascertain that XLA
+// was used for their TF model.
+// Prints only once to avoid spamming LOG(INFO).
+inline void LogOnceXlaCompiledFirstCluster() {
+  static absl::once_flag log_once;
+  absl::call_once(log_once, [] {
+    LOG(INFO) << "Compiled cluster using XLA!  This line is logged at most "
+                 "once for the lifetime of the process.";
+  });
+}
+
+template <typename ExecutableType>
+inline Status EligibleToPersist(DeviceCompileState compile_state,
+                                const ExecutableType* executable) {
+  if (compile_state != DeviceCompileState::kCompiled) {
+    return errors::FailedPrecondition(
+        "Cache entry to serialize is not compiled.");
+  }
+  if (executable == nullptr) {
+    return errors::FailedPrecondition(
+        "LocalExecutable not found for cache entry to serialize.");
+  }
+  return OkStatus();
+}
+}  // namespace device_compiler_internal
+
+template <typename ExecutableType, typename ClientType>
+DeviceCompiler<ExecutableType, ClientType>::DeviceCompiler(
+    std::unique_ptr<DeviceExecutablePersistor<ExecutableType, ClientType>>
+        persistor,
+    std::unique_ptr<DeviceCompilerClient<ExecutableType, ClientType>>
+        compiler_client)
+    : persistor_(std::move(persistor)),
+      compiler_client_(std::move(compiler_client)) {
+  cache_ = std::make_unique<DeviceCompilationCache<ExecutableType>>();
+  async_compiler_threads_ = std::make_unique<tensorflow::thread::ThreadPool>(
+      tensorflow::Env::Default(), "async_compiler_threads",
+      kNumAsyncDeviceCompilerThreads);
+}
+
+template <typename ExecutableType, typename ClientType>
+DeviceCompiler<ExecutableType, ClientType>::~DeviceCompiler() {
+  // Since programs are owned by the cache, ensure any use of our programs have
+  // completed by waiting for all stream executors to complete.
+  compiler_client_->WaitForProgramsToFinish();
+  // Wait for all outstanding compilations to finish.
+  // Resetting the pointer explicitly in the top level destructor.
+  // Without this, the pointer would be reset when the AsyncCompilationState
+  // is destructed, which is dependent on the order of the members in the
+  // DeviceCompiler class, which is error prone if the order changes.
+  async_compiler_threads_.reset();
+  // TODO(b/110813685): Think about the program ownership model. Programs are
+  // currently owned by the compilation cache which means we must wait for
+  // program completion in the destructor. There are multiple compilation caches
+  // around, which complicates things a little. Perhaps having programs be
+  // shared_ptrs (an invasive change) would make the model easier to reason
+  // about?
+}
+
+template <typename ExecutableType, typename ClientType>
+string DeviceCompiler<ExecutableType, ClientType>::DebugString() const {
+  return "DeviceCompiler";
+}
+
+template <typename ExecutableType, typename ClientType>
+Status DeviceCompiler<ExecutableType, ClientType>::CompileIfNeeded(
+    const XlaCompiler::Options& options, const NameAttrList& function,
+    const std::vector<XlaCompiler::Argument>& args,
+    const XlaCompiler::CompileOptions& compile_options,
+    DeviceCompileMode compile_mode, DeviceCompilationProfiler* profiler,
+    const XlaCompiler::CompilationResult** out_compilation_result,
+    ExecutableType** out_executable) {
+  return CompileImpl(compile_options, options, function, args,
+                     CompileScope::kFunction, compile_mode, /*ctx=*/nullptr,
+                     profiler, out_compilation_result, out_executable);
+}
+
+template <typename ExecutableType, typename ClientType>
+Status DeviceCompiler<ExecutableType, ClientType>::CompileSingleOpIfNeeded(
+    const XlaCompiler::Options& options,
+    const std::vector<XlaCompiler::Argument>& args,
+    const XlaCompiler::CompileOptions& compile_options, OpKernelContext* ctx,
+    DeviceCompilationProfiler* profiler,
+    const XlaCompiler::CompilationResult** out_compilation_result,
+    ExecutableType** out_executable) {
+  const NodeDef& def = ctx->op_kernel().def();
+  NameAttrList name;
+  name.set_name(def.op());
+  *name.mutable_attr() = def.attr();
+  // Remove the "_class" attribute from the attribute set used to create the
+  // compilation cache key. This attribute is information for the colocator
+  // and causes false uniqueness between nodes.
+  name.mutable_attr()->erase("_class");
+  return CompileImpl(compile_options, options, name, args, CompileScope::kOp,
+                     DeviceCompileMode::kStrict, ctx, profiler,
+                     out_compilation_result, out_executable);
+}
+
+template <typename ExecutableType, typename ClientType>
+StatusOr<typename DeviceCompilationCache<ExecutableType>::Value>
+DeviceCompiler<ExecutableType, ClientType>::CompileStrict(
+    const DeviceCompilationClusterSignature& sig,
+    const XlaCompiler::CompileOptions& compile_options,
+    const XlaCompiler::Options& options,
+    const std::vector<XlaCompiler::Argument>& args,
+    const NameAttrList& function,
+    typename DeviceCompilationCache<ExecutableType>::Value cache_value,
+    CompileScope scope, OpKernelContext* ctx,
+    DeviceCompilationProfiler* profiler, mutex* mu) {
+  tensorflow::Env* env = tensorflow::Env::Default();
+  const uint64 compile_start_us = env->NowMicros();
+
+  TfGraphToHloCompiler compiler(options);
+  cache_value.compile_state = DeviceCompileState::kCompiled;
+
+  std::unique_ptr<ExecutableType> out_executable;
+  auto out_compilation_result =
+      std::make_unique<XlaCompiler::CompilationResult>();
+
+  if (scope == CompileScope::kOp) {
+    cache_value.compilation_status = compiler.CompileSingleOp(
+        compile_options, ctx, args, out_compilation_result.get());
+  } else {
+    CHECK(scope == CompileScope::kFunction);  // Crash OK
+    cache_value.compilation_status = compiler.Compile(
+        compile_options, function, args, out_compilation_result.get());
+  }
+  TF_RETURN_IF_ERROR(cache_value.compilation_status);
+  TF_RET_CHECK(cache_value.executable == nullptr);
+  TF_RET_CHECK(out_compilation_result->computation != nullptr);
+
+  auto loaded_executable = persistor_->TryToLoadExecutable(
+      DeviceCompilationClusterSignature::Hash()(sig), sig.HumanString(),
+      options, *out_compilation_result, compiler_client_.get());
+
+  if (loaded_executable.has_value()) {
+    cache_value.compilation_status = loaded_executable->status();
+    if (loaded_executable->ok()) {
+      out_executable = *std::move(*loaded_executable);
+    }
+  } else {
+    auto built_executable =
+        compiler_client_->BuildExecutable(options, *out_compilation_result);
+    TF_RETURN_IF_ERROR(built_executable.status());
+    out_executable = *std::move(built_executable);
+
+    TF_RETURN_IF_ERROR(
+        device_compiler_internal::EligibleToPersist<ExecutableType>(
+            cache_value.compile_state, out_executable.get()));
+    TF_RETURN_IF_ERROR(persistor_->TryToPersistExecutable(
+        DeviceCompilationClusterSignature::Hash()(sig), sig.HumanString(),
+        options, *out_compilation_result, *out_executable,
+        compiler_client_.get()));
+  }
+
+  cache_value.compilation_result = out_compilation_result.get();
+  cache_value.executable = out_executable.get();
+  cache_->Store(sig, cache_value.compile_state, cache_value.compilation_status,
+                std::move(out_compilation_result), std::move(out_executable));
+
+  const uint64 compile_end_us = env->NowMicros();
+  const uint64 compile_time_us = compile_end_us - compile_start_us;
+
+  device_compiler_internal::LogOnceXlaCompiledFirstCluster();
+  TF_RETURN_IF_ERROR(profiler->RegisterCompilation(
+      function, compile_time_us, loaded_executable.has_value()));
+  return cache_value;
+}
+
+template <typename ExecutableType, typename ClientType>
+Status DeviceCompiler<ExecutableType, ClientType>::CompileAsynchronous(
+    const DeviceCompilationClusterSignature& signature,
+    const XlaCompiler::CompileOptions& compile_options,
+    const XlaCompiler::Options& options,
+    const std::vector<XlaCompiler::Argument>& args,
+    const NameAttrList& function, CompileScope scope, OpKernelContext* ctx,
+    DeviceCompilationProfiler* profiler) {
+  // Explicitly capture all required data by value for async compilation.
+  // Update compilation state in cache.
+  cache_->Store(signature, DeviceCompileState::kCompiling, std::nullopt,
+                std::nullopt, std::nullopt);
+  profiler->IncrementOngoingAsyncCompilations();
+  // Don't move the above code into the thread function as it synchronously
+  // updates the async compilation state!
+
+  // When the ThreadPool for the compilation cache is destroyed, it waits for
+  // compilations to have finished. This means that both 'entry' and 'this' will
+  // be alive for the duration of the compilation.
+  // !!Pay attention when additional variables must be captured by this lambda!!
+  // All values are captured by value. Make sure that all pointer values (like
+  // entry) do not get freed until the lambda has finished.
+  const std::string& function_name = function.name();
+  async_compiler_threads_->Schedule([=] {
+    VLOG(2) << "Starting asynchronous compilation of cluster " << function_name
+            << '.';
+    // We don't need to lock mu, but do it anyway to satisfy thread safety
+    // analysis.
+    mutex mu;
+    mutex_lock lock(mu);
+    auto cache_value = typename DeviceCompilationCache<ExecutableType>::Value();
+    auto s = CompileStrict(signature, compile_options, options, args, function,
+                           cache_value, scope, ctx, profiler, &mu);
+    VLOG(2) << "Finished asynchronous compililation of cluster "
+            << function_name << '.';
+    profiler->DecrementOngoingAsyncCompilations();
+    // Update compilation status in cache.
+    if (!s.ok()) {
+      cache_->Store(signature, std::nullopt, s.status(), std::nullopt,
+                    std::nullopt);
+    }
+  });
+  return OkStatus();
+}
+
+template <typename ExecutableType, typename ClientType>
+Status DeviceCompiler<ExecutableType, ClientType>::CompileImpl(
+    const XlaCompiler::CompileOptions& compile_options,
+    const XlaCompiler::Options& options, const NameAttrList& function,
+    const std::vector<XlaCompiler::Argument>& args, CompileScope scope,
+    DeviceCompileMode compile_mode, OpKernelContext* ctx,
+    DeviceCompilationProfiler* profiler,
+    const XlaCompiler::CompilationResult** out_compilation_result,
+    ExecutableType** out_executable) {
+  DCHECK_NE(out_executable, nullptr);
+  VLOG(2) << "DeviceCompiler::Compile " << DebugString();
+
+  if (VLOG_IS_ON(2)) {
+    VLOG(2) << "num_inputs=" << args.size();
+    for (int i = 0, end = args.size(); i < end; i++) {
+      VLOG(3) << i << ": " << args[i].HumanString();
+    }
+  }
+  TF_ASSIGN_OR_RETURN(auto signature,
+                      DeviceCompilationClusterSignature::Build(function, args));
+
+  // The outer lock protects the existence of the mutex in the map.
+  mutex* cluster_mutex;
+  {
+    mutex_lock lock(cluster_mutexes_mu_);
+    auto it =
+        cluster_mutexes_.emplace(signature, std::make_unique<mutex>()).first;
+    cluster_mutex = it->second.get();
+  }
+
+  profiler->RegisterExecution(function);
+
+  string human_signature;
+  if (VLOG_IS_ON(2)) {
+    human_signature = VLOG_IS_ON(3) ? signature.HumanString() : function.name();
+    VLOG(2) << "DeviceCompilationClusterSignature: " << human_signature;
+  }
+
+  // Acquire the cache entry lock and compile, if necessary.
+  // TODO(phawkins): this locking will need to be restructured when we implement
+  // cache eviction.
+  mutex_lock cluster_compile_lock(*cluster_mutex);
+  auto cache_value = cache_->LookupOrCreate(signature);
+
+  int64_t current_request_count = cache_value.request_count;
+  VLOG(2) << "Compilation cache entry hit: "
+          << static_cast<int>(cache_value.compile_state)
+          << " signature: " << human_signature << " with request count "
+          << current_request_count;
+
+  DeviceCompileState state = cache_value.compile_state;
+  *out_compilation_result = nullptr;
+  *out_executable = nullptr;
+
+  // Check if the requested entry is uncompiled and return an error if
+  // compilation is disabled. This will raise an error for kLazy even if we have
+  // not yet hit the compilation threshold and no compilation happens this
+  // round. This is to avoid non-determanism of when compilation is disallowed,
+  // for example by changing the threshold.
+  if (state == DeviceCompileState::kUncompiled && FailOnXlaCompilation()) {
+    VLOG(1) << "XLA compilation disabled: " << function.name() << "\n"
+            << absl::StrJoin(
+                   args, "\n",
+                   [](std::string* out, const XlaCompiler::Argument& arg) {
+                     absl::StrAppend(out, " arg: ", arg.HumanString());
+                   });
+
+    return errors::Internal("XLA compilation disabled");
+  }
+
+  if (state == DeviceCompileState::kUncompiled) {
+    XLA_SCOPED_LOGGING_TIMER("Compilation of XLA executable");
+    if (!profiler->ShouldCompileCluster(function, compile_mode,
+                                        current_request_count)) {
+      VLOG(2) << "Not compiling for signature: " << human_signature;
+      return OkStatus();
+    } else if (compile_mode == DeviceCompileMode::kAsync) {
+      VLOG(2) << "Queueing asynchronous compilation for signature: "
+              << human_signature;
+      TF_RETURN_IF_ERROR(CompileAsynchronous(signature, compile_options,
+                                             options, args, function, scope,
+                                             ctx, profiler));
+      return OkStatus();
+    } else {
+      VLOG(2) << "Instantly compiling for signature: " << human_signature;
+      TF_ASSIGN_OR_RETURN(
+          cache_value,
+          CompileStrict(signature, compile_options, options, args, function,
+                        cache_value, scope, ctx, profiler, cluster_mutex));
+    }
+  } else if (state == DeviceCompileState::kCompiling) {
+    VLOG(2) << "Ongoing asynchronous compilation for signature: "
+            << human_signature;
+    return OkStatus();
+  } else if (state == DeviceCompileState::kCompiled) {
+    VLOG(2) << "Already Compiled for signature: " << human_signature;
+  }
+
+  TF_RETURN_IF_ERROR(cache_value.compilation_status);
+  *out_compilation_result = cache_value.compilation_result;
+  *out_executable = cache_value.executable;
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_compiler_client.h

@@ -0,0 +1,75 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_CLIENT_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_CLIENT_H_
+
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "tensorflow/compiler/tf2xla/xla_compiler.h"
+#include "xla/client/executable_build_options.h"
+
+namespace tensorflow {
+
+template <typename ExecutableType, typename ClientType>
+class DeviceCompilerClient {
+ public:
+  DeviceCompilerClient() = default;
+  virtual ~DeviceCompilerClient() = default;
+
+  // Compiles `result` (HLO) to an `ExecutableType` using `ClientType` and
+  // returns it.
+  virtual StatusOr<std::unique_ptr<ExecutableType>> BuildExecutable(
+      const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& result) = 0;
+
+  // Serializes an available `executable` to string using `ClientType` and
+  // returns it.
+  virtual StatusOr<std::string> SerializeExecutable(
+      const ExecutableType& executable) = 0;
+
+  // Compiles `result` (HLO) to a serializable executable (eg.
+  // xla::AotCompilationResult) using `ClientType`, serializes it to string and
+  // returns it.
+  virtual StatusOr<std::string> BuildSerializedExecutable(
+      const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& result) = 0;
+
+  // Loads `serialized_executable` into an `ExecutableType` using `ClientType`.
+  virtual StatusOr<std::unique_ptr<ExecutableType>> LoadExecutable(
+      const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& result,
+      const std::string& serialized_executable) = 0;
+
+  // Waits for the underlying `ClientType` backend's programs to finish
+  // executing before returning.
+  virtual void WaitForProgramsToFinish() = 0;
+
+  virtual ClientType* client() const = 0;
+
+ private:
+  TF_DISALLOW_COPY_AND_ASSIGN(DeviceCompilerClient);
+};
+
+// Generates the ExecutableBuildOptions for compilation from HLO to
+// executable.
+xla::ExecutableBuildOptions GetExecutableBuildOptions(
+    const XlaCompiler::Options& options,
+    const XlaCompiler::CompilationResult& result, int default_device_ordinal);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_COMPILER_CLIENT_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_executable_persistor.h

@@ -0,0 +1,408 @@
+/* Copyright 2022 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_EXECUTABLE_PERSISTOR_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_EXECUTABLE_PERSISTOR_H_
+
+#include <optional>
+#include <string>
+
+#include "absl/log/log.h"
+#include "tensorflow/compiler/jit/xla_compilation_cache.pb.h"
+#include "tensorflow/compiler/jit/xla_device_compiler_client.h"
+#include "tensorflow/compiler/tf2xla/xla_compiler.h"
+#include "xla/pjrt/pjrt_client.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/util.h"
+#include "tensorflow/core/framework/device.h"
+#include "tensorflow/core/lib/strings/proto_serialization.h"
+#include "tensorflow/core/platform/path.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tsl/platform/statusor.h"
+
+namespace tensorflow {
+
+// Offers a way to persist and/or load compiled `ExecutableType`s along with the
+// corresponding HLO (`CompilationResult`) to/from `persistent_cache_directory`
+// (if one was provided during construction) on disk  using `ClientType`.
+template <typename ExecutableType, typename ClientType>
+class DeviceExecutablePersistor {
+ public:
+  // Configuration for setting up persistence (directory, filename prefix, etc).
+  struct Config {
+    Config() = default;
+    explicit Config(absl::string_view persistent_cache_directory,
+                    bool disable_strict_signature_checks,
+                    absl::string_view persistence_prefix,
+                    bool persistent_cache_directory_read_only)
+        : persistent_cache_directory(persistent_cache_directory),
+          disable_strict_signature_checks(disable_strict_signature_checks),
+          persistence_prefix(persistence_prefix),
+          persistent_cache_directory_read_only(
+              persistent_cache_directory_read_only) {}
+
+    explicit Config(absl::string_view persistent_cache_directory,
+                    bool disable_strict_signature_checks,
+                    absl::string_view persistence_prefix)
+        : persistent_cache_directory(persistent_cache_directory),
+          disable_strict_signature_checks(disable_strict_signature_checks),
+          persistence_prefix(persistence_prefix) {}
+
+    // If non-empty, JIT-compiled executables are saved to and loaded from the
+    // specified file system directory path.
+    std::string persistent_cache_directory;
+
+    // Disable strict signature checks for entries loaded into the cache from
+    // external sources.
+    bool disable_strict_signature_checks = false;
+
+    // The cache persistence prefix to use if serializing/deserialzing entries.
+    std::string persistence_prefix;
+
+    // Cache is read-only if set to true.
+    bool persistent_cache_directory_read_only = false;
+  };
+
+  DeviceExecutablePersistor(const Config& config,
+                            const DeviceType& device_type);
+  virtual ~DeviceExecutablePersistor() = default;
+
+  // Returns std::nullopt if persistence is not enabled (i.e.
+  // `persistent_cache_directory_` is empty) or if the serialized entry is not
+  // found on disk. Otherwise, loads and returns the serialized executable
+  // (or returns a status).
+  // TODO(b/255826209): Take in Signature instead of hash and string once cache
+  // is refactored.
+  std::optional<StatusOr<std::unique_ptr<ExecutableType>>> TryToLoadExecutable(
+      uint64 signature_hash, const std::string& signature_str,
+      const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& compilation_result,
+      DeviceCompilerClient<ExecutableType, ClientType>* client) const;
+
+  // Tries to serialize an already built `executable` and persist it on disk. If
+  // unable to do so, tries to build a serialized executable using the AOT
+  // pipeline and persists that to disk.
+  // TODO(b/255826209): Take in Signature instead hash and string once cache
+  // is refactored.
+  virtual Status TryToPersistExecutable(
+      uint64 signature_hash, const std::string& signature_str,
+      const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& compilation_result,
+      const ExecutableType& executable,
+      DeviceCompilerClient<ExecutableType, ClientType>* client) const;
+
+  const DeviceType& device_type() const { return device_type_; }
+  const std::string& persistence_prefix() const { return persistence_prefix_; }
+  const std::string& persistent_cache_directory() const {
+    return persistent_cache_directory_;
+  }
+
+ private:
+  // Returns a cache key proto that identifies an entry in the compilation
+  // cache.
+  XlaSerializedCacheKey BuildSerializedCacheKey(
+      uint64 signature_hash, const xla::HloModuleProto& hlo_module) const;
+
+  XlaSerializedCacheKey BuildSerializedCacheKey(
+      uint64 signature_hash, const xla::HloModuleProto& hlo_module,
+      bool compiled_using_pjrt) const;
+
+  // Serializes the signature and its corresponding entry to a proto message.
+  StatusOr<XlaSerializedCacheEntry> SerializeEntry(
+      uint64 signature_hash, const XlaCompiler::Options& options,
+      const XlaCompiler::CompilationResult& compilation_result,
+      const ExecutableType& executable,
+      DeviceCompilerClient<ExecutableType, ClientType>* compiler_client) const;
+
+  // Saves the cache entry in the file directory supplied during the
+  // construction of this class. Overwrites existing entries.
+  Status SaveSerializedEntry(const XlaSerializedCacheEntry& entry) const;
+
+  // Tries to read a cache entry given a `key` by searching the file directory
+  // supplied during the construction of this class. Returns std::nullopt if no
+  // cache entry is found.
+  StatusOr<std::optional<XlaSerializedCacheEntry>> TryToReadSerializedEntry(
+      const XlaSerializedCacheKey& key) const;
+
+  // Checks if the loaded `entry` matches the expected `key` and `hlo_module`.
+  Status VerifyLoadedCacheEntry(const XlaSerializedCacheKey& key,
+                                const xla::HloModuleProto& hlo_module,
+                                const XlaSerializedCacheEntry& entry) const;
+
+  std::string XlaSerializedCacheKeyToString(
+      const XlaSerializedCacheKey& key) const;
+  std::string GetFilePath(const XlaSerializedCacheKey& key) const;
+
+  const DeviceType device_type_;
+  const bool disable_strict_signature_checks_;
+  const std::string persistence_prefix_;
+
+  // If non-empty, JIT-compiled executables are saved to and loaded from the
+  // specified file system directory path.
+  const std::string persistent_cache_directory_;
+
+  // Cache is read-only if set to true.
+  const bool persistent_cache_directory_read_only_;
+
+  TF_DISALLOW_COPY_AND_ASSIGN(DeviceExecutablePersistor);
+};
+
+template <typename ExecutableType, typename ClientType>
+DeviceExecutablePersistor<ExecutableType, ClientType>::
+    DeviceExecutablePersistor(const Config& config,
+                              const DeviceType& device_type)
+    : device_type_(device_type),
+      disable_strict_signature_checks_(config.disable_strict_signature_checks),
+      persistence_prefix_(config.persistence_prefix),
+      persistent_cache_directory_(config.persistent_cache_directory),
+      persistent_cache_directory_read_only_(
+          config.persistent_cache_directory_read_only) {}
+
+template <typename ExecutableType, typename ClientType>
+std::string DeviceExecutablePersistor<ExecutableType, ClientType>::
+    XlaSerializedCacheKeyToString(const XlaSerializedCacheKey& key) const {
+  static constexpr char kXlaSerializedCacheKeySeparator[] = "__";
+  return absl::StrCat(
+      key.prefix(), key.prefix().empty() ? "" : kXlaSerializedCacheKeySeparator,
+      key.signature_fingerprint(), kXlaSerializedCacheKeySeparator,
+      key.cluster_fingerprint(), kXlaSerializedCacheKeySeparator,
+      key.device_type(),
+      key.compiled_using_pjrt()
+          ? absl::StrCat(kXlaSerializedCacheKeySeparator, "pjrt")
+          : "");
+}
+
+template <typename ExecutableType, typename ClientType>
+std::string DeviceExecutablePersistor<ExecutableType, ClientType>::GetFilePath(
+    const XlaSerializedCacheKey& key) const {
+  const std::string file_name =
+      absl::StrCat(XlaSerializedCacheKeyToString(key), ".pb");
+  return io::JoinPath(persistent_cache_directory_, file_name);
+}
+
+template <typename ExecutableType, typename ClientType>
+XlaSerializedCacheKey
+DeviceExecutablePersistor<ExecutableType, ClientType>::BuildSerializedCacheKey(
+    uint64 signature_hash, const xla::HloModuleProto& hlo_module,
+    bool compiled_using_pjrt) const {
+  XlaSerializedCacheKey key;
+  key.set_signature_fingerprint(signature_hash);
+  key.set_cluster_fingerprint(DeterministicProtoHash64(hlo_module));
+  key.set_device_type(device_type().type_string());
+  key.set_prefix(persistence_prefix());
+  key.set_compiled_using_pjrt(compiled_using_pjrt);
+  return key;
+}
+
+template <typename ExecutableType, typename ClientType>
+XlaSerializedCacheKey
+DeviceExecutablePersistor<ExecutableType, ClientType>::BuildSerializedCacheKey(
+    uint64 signature_hash, const xla::HloModuleProto& hlo_module) const {
+  return BuildSerializedCacheKey(signature_hash, hlo_module, false);
+}
+
+// This template specialization sets compiled_using_prjt to true in the cache
+// key when the template arguments are PjRtLoadedExecutable and PjRtClient.
+template <>
+inline XlaSerializedCacheKey
+DeviceExecutablePersistor<xla::PjRtLoadedExecutable, xla::PjRtClient>::
+    BuildSerializedCacheKey(uint64 signature_hash,
+                            const xla::HloModuleProto& hlo_module) const {
+  return BuildSerializedCacheKey(signature_hash, hlo_module, true);
+}
+
+template <typename ExecutableType, typename ClientType>
+StatusOr<std::optional<XlaSerializedCacheEntry>>
+DeviceExecutablePersistor<ExecutableType, ClientType>::TryToReadSerializedEntry(
+    const XlaSerializedCacheKey& key) const {
+  Env* env = Env::Default();
+  const std::string file_path = GetFilePath(key);
+  if (!env->FileExists(file_path).ok()) {
+    return StatusOr<std::optional<XlaSerializedCacheEntry>>(std::nullopt);
+  }
+
+  XlaSerializedCacheEntry entry;
+  TF_RETURN_IF_ERROR(ReadTextOrBinaryProto(env, file_path, &entry));
+  return std::optional<XlaSerializedCacheEntry>(entry);
+}
+
+template <typename ExecutableType, typename ClientType>
+Status
+DeviceExecutablePersistor<ExecutableType, ClientType>::VerifyLoadedCacheEntry(
+    const XlaSerializedCacheKey& key, const xla::HloModuleProto& hlo_module,
+    const XlaSerializedCacheEntry& entry) const {
+  XLA_SCOPED_LOGGING_TIMER(absl::StrCat("Verifying loaded cache entry: ",
+                                        hlo_module.entry_computation_name()));
+
+  if (!AreSerializedProtosEqual(key, entry.key())) {
+    VLOG(2) << "Serialized cache key does not match:\n"
+            << "got:\n"
+            << entry.key().DebugString() << "\nexpected:\n"
+            << key.DebugString() << "\n";
+    return errors::InvalidArgument("Serialized cache key does not match.");
+  }
+
+  // Perform a stricter (slower) check of the snapshot to verify that they
+  // match exactly.
+  if (!disable_strict_signature_checks_) {
+    if (!AreSerializedProtosEqual(hlo_module, entry.hlo_module())) {
+      VLOG(2) << "HLOs do not match:\n"
+              << "got:\n"
+              << hlo_module.DebugString() << "\nexpected:\n"
+              << entry.hlo_module().DebugString() << "\n";
+      return errors::InvalidArgument("Serialized HLO does not match.");
+    }
+  }
+
+  if (entry.executable().empty()) {
+    return errors::InvalidArgument("No binary found in serialized entry.");
+  }
+  return OkStatus();
+}
+
+template <typename ExecutableType, typename ClientType>
+Status
+DeviceExecutablePersistor<ExecutableType, ClientType>::SaveSerializedEntry(
+    const XlaSerializedCacheEntry& entry) const {
+  Env* env = Env::Default();
+  TF_RETURN_IF_ERROR(env->RecursivelyCreateDir(persistent_cache_directory_));
+
+  // The cache on the filesystem can be read while we're writing out the proto.
+  // To prevent reads of partially-written files, we write the proto to a temp
+  // file, then move it into place once we're done writing.  And we warn the
+  // user if these moves are not known to be atomic.
+  bool has_atomic_move = false;
+  env->HasAtomicMove(persistent_cache_directory_, &has_atomic_move)
+      .IgnoreError();
+  if (!has_atomic_move) {
+    LOG_EVERY_POW_2(WARNING)
+        << "Filesystem for XLA persistent cache at "
+        << persistent_cache_directory_
+        << " does not support atomic moves.  Therefore the persistent cache is "
+           "racy if you have multiple XLA compilations occurring "
+           "simultaneously!  You have been warned. :)";
+  }
+
+  // Write to temp location, then when that completes, atomically move into the
+  // final location.
+  std::string temp_path = io::JoinPath(
+      persistent_cache_directory_, XlaSerializedCacheKeyToString(entry.key()));
+  if (!env->CreateUniqueFileName(&temp_path, ".pb.tmp")) {
+    return absl::UnavailableError(absl::StrCat(
+        "Could not create a unique file inside ", persistent_cache_directory_));
+  }
+  TF_RETURN_IF_ERROR(WriteBinaryProto(env, temp_path, entry));
+  return env->RenameFile(temp_path, GetFilePath(entry.key()));
+}
+
+template <typename ExecutableType, typename ClientType>
+StatusOr<XlaSerializedCacheEntry>
+DeviceExecutablePersistor<ExecutableType, ClientType>::SerializeEntry(
+    uint64 signature_hash, const XlaCompiler::Options& options,
+    const XlaCompiler::CompilationResult& compilation_result,
+    const ExecutableType& executable,
+    DeviceCompilerClient<ExecutableType, ClientType>* compiler_client) const {
+  XlaSerializedCacheEntry serialized_entry;
+  const xla::HloModuleProto& hlo_module =
+      compilation_result.computation->proto();
+  *serialized_entry.mutable_key() =
+      BuildSerializedCacheKey(signature_hash, hlo_module);
+  *serialized_entry.mutable_hlo_module() = hlo_module;
+
+  // XLA compiler supports exporting executables as an AOT compilation result
+  // to avoid running potentially expensive compilation pipeline twice.
+  // Check if XLA compiler can export available executable.
+  if (auto serialized_executable =
+          compiler_client->SerializeExecutable(executable);
+      serialized_executable.ok()) {
+    serialized_entry.set_executable(std::move(*serialized_executable));
+    return serialized_entry;
+  } else if (serialized_executable.status().code() == error::UNIMPLEMENTED) {
+    VLOG(1) << "Executable export is not implemented";
+  } else {
+    return serialized_executable.status();
+  }
+
+  TF_ASSIGN_OR_RETURN(
+      auto serialized_executable,
+      compiler_client->BuildSerializedExecutable(options, compilation_result));
+  serialized_entry.set_executable(std::move(serialized_executable));
+  return serialized_entry;
+}
+
+template <typename ExecutableType, typename ClientType>
+std::optional<StatusOr<std::unique_ptr<ExecutableType>>>
+DeviceExecutablePersistor<ExecutableType, ClientType>::TryToLoadExecutable(
+    uint64 signature_hash, const std::string& signature_str,
+    const XlaCompiler::Options& options,
+    const XlaCompiler::CompilationResult& compilation_result,
+    DeviceCompilerClient<ExecutableType, ClientType>* compiler_client) const {
+  if (persistent_cache_directory_.empty()) {
+    return std::nullopt;
+  }
+
+  const xla::HloModuleProto& hlo_module =
+      compilation_result.computation->proto();
+
+  XlaSerializedCacheKey cache_key =
+      BuildSerializedCacheKey(signature_hash, hlo_module);
+
+  std::optional<XlaSerializedCacheEntry> serialized_entry;
+  {
+    XLA_SCOPED_LOGGING_TIMER(
+        absl::StrCat("Try loading serialized cache entry:", signature_str));
+    TF_ASSIGN_OR_RETURN(serialized_entry, TryToReadSerializedEntry(cache_key));
+  }
+
+  if (!serialized_entry.has_value()) {
+    return std::nullopt;
+  }
+
+  TF_RETURN_IF_ERROR(
+      VerifyLoadedCacheEntry(cache_key, hlo_module, *serialized_entry));
+
+  VLOG(1) << "Loading cached entry for: " << signature_str;
+  return compiler_client->LoadExecutable(options, compilation_result,
+                                         serialized_entry->executable());
+}
+
+template <typename ExecutableType, typename ClientType>
+Status
+DeviceExecutablePersistor<ExecutableType, ClientType>::TryToPersistExecutable(
+    uint64 signature_hash, const std::string& signature_str,
+    const XlaCompiler::Options& options,
+    const XlaCompiler::CompilationResult& compilation_result,
+    const ExecutableType& executable,
+    DeviceCompilerClient<ExecutableType, ClientType>* client) const {
+  if (persistent_cache_directory_.empty() ||
+      persistent_cache_directory_read_only_) {
+    VLOG(1) << "Not persisting executable. No `persistent_cache_directory` "
+               "provided or cache is read-only.";
+    return OkStatus();
+  }
+
+  XLA_SCOPED_LOGGING_TIMER(
+      absl::StrCat("Serializing and saving cache entry: ", signature_str));
+  TF_ASSIGN_OR_RETURN(XlaSerializedCacheEntry serialized_entry,
+                      SerializeEntry(signature_hash, options,
+                                     compilation_result, executable, client));
+  TF_RETURN_IF_ERROR(SaveSerializedEntry(std::move(serialized_entry)));
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_EXECUTABLE_PERSISTOR_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/device_util.h

@@ -0,0 +1,213 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_DEVICE_UTIL_H_
+#define TENSORFLOW_COMPILER_JIT_DEVICE_UTIL_H_
+
+#include <functional>
+#include <memory>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/compiler/tf2xla/xla_op_registry.h"
+#include "xla/status_macros.h"
+#include "xla/statusor.h"
+#include "tensorflow/core/framework/types.h"
+
+namespace tensorflow {
+namespace jit {
+class DeviceInfoCache;
+class DeviceSet;
+
+// Instances of DeviceId represent TensorFlow devices as integers.
+//
+// This helps avoid having to manipulate device names as strings when
+// auto-clustering.
+class DeviceId {
+ public:
+  DeviceId(DeviceId&&) = default;
+  DeviceId(const DeviceId&) = default;
+  DeviceId& operator=(const DeviceId&) = default;
+
+  bool operator==(const DeviceId& other) const { return id() == other.id(); }
+  bool operator!=(const DeviceId& other) const { return !(*this == other); }
+
+ private:
+  int id_;
+
+  explicit DeviceId(int id) : id_(id) {}
+
+  int id() const { return id_; }
+
+  friend class DeviceInfoCache;
+  friend class DeviceSet;
+};
+
+// A set of DeviceIds, represented as a bitmap.
+class DeviceSet {
+ public:
+  void Insert(DeviceId device_id);
+  void UnionWith(const DeviceSet& other);
+  bool IsEmpty() const;
+
+  // Calls `func` on each DeviceId in the set.  Stops iterating early if `func`
+  // return false.
+  //
+  // TODO(sanjoy): Change this to take a typed std::function if that's
+  // performance neutral.
+  template <typename FnTy>
+  void ForEach(FnTy func) const {
+    // This is really a poor man's iterator, we should consider writing a proper
+    // iterator if this ends up being used widely.
+    for (int word_index = 0, end = storage_.size(); word_index < end;
+         word_index++) {
+      uint64 word = storage_[word_index];
+      while (word != 0) {
+        uint64 only_lowest_bit_set = word & -word;
+        // The number of trailing zeros in a non-zero word is the index of the
+        // least significant 1.
+        int bit_index = ctz_uint64(word);
+        if (!func(DeviceId(word_index * kWordSize + bit_index))) {
+          return;
+        }
+        word ^= only_lowest_bit_set;
+      }
+    }
+  }
+
+ private:
+  static int ctz_uint64(uint64 x) {
+    DCHECK_NE(x, 0);
+#ifdef __GNUC__
+    return __builtin_ctzl(x);
+#else
+    int result = 0u;
+    while ((x & 1u) == 0u) {
+      x >>= 1;
+      ++result;
+    }
+    return result;
+#endif
+  }
+
+  absl::InlinedVector<uint64, 1> storage_;
+
+  const int kWordSize = 64;
+};
+
+// Caches some miscellaneous information about TF devices.  Thread compatible.
+class DeviceInfoCache {
+ public:
+  bool IsGpu(DeviceId device) const { return is_gpu_[device.id()]; }
+  bool IsCpu(DeviceId device) const { return is_cpu_[device.id()]; }
+
+  absl::string_view GetNameFor(DeviceId device) const {
+    return names_[device.id()];
+  }
+
+  StatusOr<DeviceId> GetIdFor(absl::string_view name);
+
+  using DeviceRegistration = const XlaOpRegistry::DeviceRegistration;
+
+  DeviceRegistration* GetCompilationDevice(DeviceId device) const {
+    return id_to_compilation_device_[device.id()];
+  }
+
+  StatusOr<DeviceRegistration*> GetCompilationDevice(absl::string_view name) {
+    TF_ASSIGN_OR_RETURN(DeviceId device_id, GetIdFor(name));
+    return GetCompilationDevice(device_id);
+  }
+
+  const DeviceType& GetDeviceTypeFor(DeviceId device) const {
+    return *id_to_device_type_[device.id()];
+  }
+
+  using DeviceTypeConstRef = std::reference_wrapper<const DeviceType>;
+
+  StatusOr<DeviceTypeConstRef> GetDeviceTypeFor(absl::string_view device_name) {
+    TF_ASSIGN_OR_RETURN(DeviceId device_id, GetIdFor(device_name));
+    return std::cref(*id_to_device_type_[device_id.id()]);
+  }
+
+  string DebugString(const DeviceSet& device_set) const;
+
+ private:
+  absl::flat_hash_map<string, DeviceId> name_to_id_;
+
+  // These fields are populated for a device in GetIdFor, *before* we give out a
+  // DeviceId.
+  std::vector<const XlaOpRegistry::DeviceRegistration*>
+      id_to_compilation_device_;
+  std::vector<std::unique_ptr<DeviceType>> id_to_device_type_;
+  std::vector<string> names_;
+  std::vector<bool> is_cpu_;
+  std::vector<bool> is_gpu_;
+};
+
+}  // namespace jit
+
+// Returns the DeviceType corresponding to 'device'.
+Status DeviceNameToDeviceType(const string& device, DeviceType* device_type);
+
+// Picks the device for which XLA should compile a cluster that contains
+// operations placed in devices in `devices`.  For instance a cluster that
+// contains operations solely placed on the CPU will be compiled into a CPU
+// executable by XLA, whereas a cluster that contains operations placed on the
+// CPU and also operations placed on the GPU will be compiled into a GPU
+// executable.
+//
+// Returns a non-OK Status if no unambiguous choice of device exists.
+//
+// We choose the device using the following rules:
+//
+//  - It is an error for `device_names` to contain more than one device of the
+//    same type.
+//  - GPU is preferred over CPU.
+//  - If `allow_mixing_unknown_and_cpu` is true then unknown devices are
+//    preferred over CPU.
+//  - XLA devices count as "unrecognized devices".
+//
+// This set of rules above implicitly assume that XLA:GPU can compile all
+// operations in the cluster that XLA:CPU can compile, and if
+// `allow_mixing_unknown_and_cpu` then the unrecognized device can also compile
+// all operations in the cluster that XLA:CPU can compile.
+//
+// We provide the `allow_mixing_unknown_and_cpu` knob so that we can do both of
+// the following things:
+//
+// - Let MarkForCompilationPass not inject CPU-placed operations into clusters
+//   that will run on unknown devices (because the unknown XLA backend may not
+//   support every operation supported by CPU).
+// - Let BuildXlaOpsPass successfully infer a compilation device for a cluster
+//   that contains nodes placed on both the CPU and on unknown devices.  In this
+//   case it is the responsibility of the optimization pass that injected the
+//   CPU nodes into the cluster to ensure that these nodes can be compiled by
+//   the unknown XLA backend.
+StatusOr<jit::DeviceId> PickDeviceForXla(
+    const jit::DeviceInfoCache& device_info_cache,
+    const jit::DeviceSet& devices, bool allow_mixing_unknown_and_cpu);
+
+// This is like `PickDeviceForXla` except that it returns nullopt (instead of a
+// non-OK Status) if no unambiguous choice of device exists.
+//
+// We return a failing Status for errors unrelated to the device choice
+// algorithm itself.
+StatusOr<std::optional<jit::DeviceId>> MaybePickDeviceForXla(
+    const jit::DeviceInfoCache& device_info_cache,
+    const jit::DeviceSet& devices, bool allow_mixing_unknown_and_cpu);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_DEVICE_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/encapsulate_subgraphs_pass.h

@@ -0,0 +1,108 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+// An optimization pass that groups nodes marked with a common
+// kXlaClusterAttr into functions, and replaces the original nodes by
+// calls. The calls are annotated with kXlaCompiledKernelAttr.
+
+#ifndef TENSORFLOW_COMPILER_JIT_ENCAPSULATE_SUBGRAPHS_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_ENCAPSULATE_SUBGRAPHS_PASS_H_
+
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// EncapsulateSubgraphs pass takes all the nodes with the same cluster ID
+// (derived from kXlaClusterAttr=ID (kXlaClusterAttr) attribute), puts them into
+// a TF function, and replaces the subgraph in the main graph with a call to
+// that TF function annotated with kXlaCompiledKernelAttr (_XlaCompiledKernel).
+class EncapsulateSubgraphsPass : public GraphOptimizationPass {
+ public:
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+
+// A rewriting function to apply to each subgraph during encapsulation.
+// 'arg_source_tensors' are the tensors corresponding to the arguments in the
+// original source graph (*not* 'graph').
+//
+// 'graph' is the subgraph. The rewriting may renumber the inputs and outputs;
+// 'input_permutation' is a mapping from old argument numbers to new argument
+// numbers, whereas 'output_permutation' is the same for outputs. Both
+// 'input_permutation' and 'output_permutation' are initialized to the identity
+// permutation. 'nodedef' is the NodeDef for the call to the function under
+// construction, provided to allow additional attributes to be set.
+// The rewrite may also change the NodeDef's operator name, and that
+// name will be used as the name of the generated function.
+typedef std::function<Status(
+    const std::vector<OutputTensor>& arg_source_tensors,
+    std::unique_ptr<Graph>* graph, std::vector<int>* input_permutation,
+    std::vector<int>* output_permutation, NodeDef* node_def)>
+    RewriteSubgraphFn;
+
+// Transformation that finds subgraphs whose nodes are marked with
+// 'group_attribute', splits those subgraphs into functions, and replaces
+// the originals with function calls.
+//
+// 'group_attribute' must be a string valued-attribute that names the new
+// functions to introduce.
+//
+// If 'rewrite_subgraph_fn' is set, it is applied to each subgraph before
+// function conversion.
+//
+// If 'reuse_existing_functions' is set, use an existing function with the
+// same name, if any.
+//
+// TODO(phawkins): currently, some information in control edges
+// is not preserved. Suppose you have A and B in the main
+// graph, C and D in a subgraph. B and C have control deps from A, D has control
+// dep from B. Originally D must run after C, post-transformation this
+// dependency is lost.
+Status EncapsulateSubgraphsInFunctions(
+    string group_attribute, const Graph& graph_in,
+    const RewriteSubgraphFn& rewrite_subgraph_fn, bool reuse_existing_functions,
+    std::unique_ptr<Graph>* graph_out, FunctionLibraryDefinition* library);
+
+// The attribute that marks function calls produced by the encapsulate
+// subgraphs pass and that should in turn be compiled via XlaLaunch operators.
+extern const char* const kXlaCompiledKernelAttr;
+
+// Does `node` have the kXlaCompiledKernelAttr attribute?
+bool IsXlaCompiledKernel(const Node& node);
+
+// Functions produced by the EncapsulateSubgraphs pass have their arguments in
+// the order:
+// 1) compile-time constant arguments, in host memory,
+// 2) other arguments, in device memory.
+// 3) resource variable arguments, in host memory. Note that only the resource
+//    Tensor itself is in host memory; the underlying value may be in device
+//    memory.
+// The functions are annotated with the following attributes that describe how
+// many constant and resource arguments there are:
+
+// Name of the attribute containing the number of constant arguments.
+extern const char* const kXlaNumConstantArgsAttr;
+
+// Name of the attribute containing the number of resource variable arguments.
+extern const char* const kXlaNumResourceArgsAttr;
+
+// Name of the attribute defining whether the cluster has reference variables.
+extern const char* const kXlaHasReferenceVarsAttr;
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_ENCAPSULATE_SUBGRAPHS_PASS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/encapsulate_util.h

@@ -0,0 +1,154 @@
+/* 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 contains some utility functions for encapsulating XLA computation
+// in host graph and encapsulating outside compilation in XLA computation.
+
+#ifndef TENSORFLOW_COMPILER_JIT_ENCAPSULATE_UTIL_H_
+#define TENSORFLOW_COMPILER_JIT_ENCAPSULATE_UTIL_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// Attribute marking output tensor shapes inferred by XLA. Attribute value is
+// a list of PartialTensorShape objects.
+extern const char kXlaInferredShapesAttrName[];
+
+// Infers output shapes for all nodes in graph `g`. The output shapes will be
+// stored in node attribute `kXlaInferredShapesAttrName`.
+//
+// We have to perform shape inference before encapsulation because after
+// encapsulation, some nodes will be encapsulated into function call, and shape
+// inference does not handle function call at the moment.
+Status PerformStaticShapeInferenceBeforeEncapsulation(Graph* g);
+
+// Attribute indicating that some ops in this node's XLA computation has control
+// dependency on this node. Attribute value will always be "true".
+extern const char kXlaConnectedToXlaComputationAttrName[];
+
+// Attribute indicating that this node has control dependency on some ops in
+// this node's XLA computation. Attribute value will always be "true".
+extern const char kXlaConnectedFromXlaComputationAttrName[];
+
+// Attribute indicating that this is an Placeholder node added to act as a
+// temporary input node for an outside compilation node. Attribute value will be
+// string (original input node name).
+extern const char kOutsideCompilationOriginalNodeAttrName[];
+
+// Attribute indicating that this is an Placeholder node added to act as a
+// temporary input node for an outside compilation node. Attribute value will be
+// int (src_output for original edge).
+extern const char kOutsideCompilationSrcOutputAttrName[];
+
+// Attribute indicating that this node has control dependencies on some other
+// nodes within the same XLA cluster. Attribute value will be a list of string
+// (node names).
+extern const char kXlaControlDependenciesWithinXlaClusterAttrName[];
+
+// Attribute indicating that this node is an outside compilation node which is
+// lifted out of If/While/function node. Attribute value will always be boolean
+// value "true".
+extern const char kXlaIsLiftedArgAttrName[];
+
+// Attribute indicating that this node is a Placeholder node for an _Arg node
+// lifted out of If/While/function node. Attribute value will be a string, which
+// is the outside compilation cluster name sending the lifted arg node to host.
+extern const char kXlaLiftedArgOutsideCompilationAttrName[];
+
+// Attribute indicating that this is an IdentityN node receiving inputs for a
+// outside compilation Placeholder node (the original outside compilation node
+// is moved out of TPU computation, and we left a Placeholder node there).
+// Attribute value will be a string, which is the outside compilation cluster
+// name for the outside compilation Placeholder node.
+extern const char kXlaOutsideCompilationInputsAttrName[];
+
+// Attribute indicating that this is a Placeholder node for an _Arg node used in
+// outside compilation. We should not move this node out of XLA computation.
+// Attribute value will always be boolean value "true".
+extern const char kXlaIsPlaceholderForArg[];
+
+// Information for XLA computation.
+struct XlaClusterInfo {
+  // Add an explicitly-defined default constructor for this class.
+  //
+  // The compiler may delete the default constructor here because
+  // host_compute_core is a const member whose type (std::map) doesn't
+  // necessarily have a user provided constructor -- while libc++ and
+  // libstdc++ 4.8 provide a user defined default constructor, libstdc++ at
+  // least >= 7.3 does not. See also c++11 [class.ctor] p5.
+  //
+  // TODO(klimek): In c++17 we'll be able to initialize host_compute_core
+  // without losing aggregate initialization, which allows us to get rid of
+  // the constructor definitions again.
+  XlaClusterInfo() {}
+  XlaClusterInfo(const string& cluster_name,
+                 const NameAttrList& func_name_attrs, Node* node,
+                 const std::map<string, int>& host_compute_core)
+      : cluster_name(cluster_name),
+        func_name_attrs(func_name_attrs),
+        node(node),
+        host_compute_core(host_compute_core) {}
+  // XLA cluster name. It might be different from `func_name`.
+  const string cluster_name;
+  // Name and attributes of XLA computation function.
+  const NameAttrList func_name_attrs;
+  // The XLA computation node in the graph.
+  Node* node;
+  // A mapping from outside compilation cluster name to its device assignment.
+  const std::map<string, int> host_compute_core;
+};
+
+// Finds dependencies between outside compilation clusters, including both data
+// dependencies and control dependencies. cluster_deps maps the name name of an
+// outside compilation cluster to a set of names of outside compilation clusters
+// that it depends on.
+tsl::StatusOr<std::unique_ptr<absl::flat_hash_map<string, std::vector<string>>>>
+OutsideCompilationClusterDependencies(
+    const Graph* g, const string& outside_compilation_attr_name);
+
+// Preprocesses edges within the same XLA cluster. It will perform the following
+// operations in order:
+//
+// 0.  Remove edges from source node to outside compilation nodes, and edges
+//     from outside compilation nodes to sink node.
+// 1a. For edges between different outside compilation clusters, remove the edge
+//     and add attr "kXlaControlDependenciesWithinXlaClusterAttrName = src node
+//     name" to dst node.
+// 1b. For control edges between outside compilation and its XLA computation,
+//     add attr "kXlaConnected{From, To}XlaComputationAttrName = true" to the
+//     outside compilation node.
+// 2.  For data edges between different outside compilations, remove the edge
+//     and create a Placeholder node as dst node's input.
+Status PreprocessEdgesBetweenOutsideCompilations(
+    Graph* g, const string& outside_compilation_attr_name);
+
+// Postprocesses edges within the same XLA cluster. This function reverts what
+// `PreprocessEdgesBetweenOutsideCompilations` did. It will perform the
+// following operations in order:
+//
+// 1. Remove Placeholder nodes between different outside compilations (created
+//    in `PreprocessEdgesBetweenOutsideCompilations` step 2).
+// 2a. Reconnect control edges between different outside compilations (marked by
+//     `PreprocessEdgesBetweenOutsideCompilations` step 1a).
+// Notice that control edges marked by
+// `PreprocessEdgesBetweenOutsideCompilations` step 1b are not handled here.
+// They are handled in `RewriteOutsideCompilationSubgraphFn`.
+Status PostprocessEdgesBetweenOutsideCompilations(
+    Graph* g, const string& outside_compilation_attr_name);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_ENCAPSULATE_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/encapsulate_xla_computations_pass.h

@@ -0,0 +1,84 @@
+/* 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.
+ ==============================================================================*/
+// Rewrites computations generated by the xla.compile() Python code into
+// XlaLaunch nodes.
+//
+// xla.compile() does two main things:
+// a) marks operators that make up an XLA computation with the attribute
+//    _xla_compile_id=XYZ, where XYZ is a unique key.
+// b) adds XlaClusterOutput nodes to represent outputs of the computation.
+//    These nodes are not marked with the _xla_compile_id attribute.
+
+#ifndef TENSORFLOW_COMPILER_JIT_ENCAPSULATE_XLA_COMPUTATIONS_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_ENCAPSULATE_XLA_COMPUTATIONS_PASS_H_
+
+#include <functional>
+#include <string>
+
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+// Encapsulates nodes marked with the _xla_compile_id attribute into
+// XlaLaunch operators.
+class EncapsulateXlaComputationsPass : public GraphOptimizationPass {
+ public:
+  Status Run(const GraphOptimizationPassOptions& options) override;
+
+  // The following methods are public only for unit tests.
+
+  // This pass has two stages:
+  // a) first, we call EncapsulateSubgraphsPass to encapsulate all nodes
+  //    marked with the same _xla_compile_id attribute into functions. These
+  //    functions contain the computations to be passed to XlaLaunch. During
+  //    encapsulation, we sort the arguments into the order expected by
+  //    XlaLaunch.
+  static Status Encapsulate(std::unique_ptr<Graph>* graph,
+                            FunctionLibraryDefinition* flib_def);
+
+  // b) we rewrite the function calls generated in phase (a) into XlaLaunch
+  //    operators. We also convert the XlaClusterOutput output nodes of the
+  //    function call into the outputs of the XlaLaunch operator.
+  static Status BuildXlaLaunchOps(Graph* graph);
+
+  struct XlaFunctionInfo {
+    int variable_start_index = -1;
+    std::string function_name;
+  };
+
+  // We need to introduce this version to adapt to the output of gpu inference
+  // converter. The single argument overload version calls this function.
+  //
+  // When add_edges_to_output_of_downstream_nodes is true, the output edges of
+  // the xla_launch_node's immediate downstream nodes would be attached to the
+  // generated xla node. For example, if the original graph is
+  // StatefulPartitionedCall{_xla_compile_id=1} -> XlaClusterOutput -> NodeA
+  // The output graph of this function would look like the following when
+  // add_edges_to_output_of_downstream_nodes is true:
+  // XlaLaunch -> NodeA
+  static Status BuildXlaLaunchOps(
+      Graph* graph,
+      const std::function<StatusOr<bool>(const Node&)>& is_xla_launch_node,
+      const std::function<StatusOr<XlaFunctionInfo>(const Node&)>&
+          get_xla_function_info,
+      bool add_edges_to_output_of_downstream_nodes);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_ENCAPSULATE_XLA_COMPUTATIONS_PASS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/extract_outside_compilation_pass.h

@@ -0,0 +1,111 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_EXTRACT_OUTSIDE_COMPILATION_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_EXTRACT_OUTSIDE_COMPILATION_PASS_H_
+
+#include "absl/types/optional.h"
+#include "tensorflow/compiler/jit/encapsulate_util.h"
+#include "xla/status_macros.h"
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// Rewrite function for outside compilation subgraphs. It will perform the
+// following steps:
+//
+// 1. Add a XLA computation key placeholder node (it will be used as input for
+//    XlaRecvAtHost and XlaSendFromHost);
+// 2. Replace all _Arg nodes with one single XlaRecvAtHost node;
+// 3. Replace all _Retval nodes with one single XlaSendFromHost node;
+// 4. Mark all nodes except key placeholder with attr `xla_cluster_attr_name`
+//    and `outside_compilation_attr_name`;
+// 5. For nodes marked with attr kXlaConnectedToXlaComputationAttrName, add a
+//    control edge from the node to XlaSendFromHost; for nodes marked with attr
+//    kXlaConnectedFromXlaComputationAttrName, add a control edge from
+//    XlaRecvAtHost node to the node;
+// 6. Try pruning XlaRecvAtHost/XlaSendFromHost/key placeholder node.
+// 7. Add necessary attributes to `node_def`, so we can replace it with a
+//    XlaHostCompute node later. If all input shapes for XlaSendFromHost are
+//    known, "shapes" attr will be set to the list of input shapes; otherwise
+//    "shape_inference_graph" attr will be set to shape inference function name.
+class RewriteOutsideCompilationSubgraphFn {
+ public:
+  RewriteOutsideCompilationSubgraphFn(
+      const string& xla_cluster_attr_name,
+      const string& outside_compilation_attr_name,
+      const string& xla_cluster_name, const string& new_function_name)
+      : xla_cluster_attr_name_(xla_cluster_attr_name),
+        outside_compilation_attr_name_(outside_compilation_attr_name),
+        xla_cluster_name_(xla_cluster_name),
+        new_function_name_(new_function_name) {}
+
+  Status operator()(const std::vector<OutputTensor>&,
+                    std::unique_ptr<Graph>* graph,
+                    std::vector<int>* input_permutation,
+                    std::vector<int>* output_permutation, NodeDef* node_def);
+
+ private:
+  string xla_cluster_attr_name_;
+  string outside_compilation_attr_name_;
+  string xla_cluster_name_;
+  string new_function_name_;
+};
+
+// For an XLA computation function, replace all outside compilations with
+// XlaHostCompute nodes. Each outside compilation subgraph will be rewritten by
+// `RewriteOutsideCompilationSubgraphFn`, and they will be merged into one
+// single host side graph (`host_graph`).
+//
+// xla_cluster_attr_name and outside_compilation_attr_name: attr name for XLA
+//   computation and outside compilation. Required for
+//   `RewriteOutsideCompilationSubgraphFn`.
+// xla_cluster_name: XLA cluster name for this XLA computation. We need it
+//   because XLA cluster name might be different from `func_name`.
+// func_name_attrs: they will be used to instantiate the XLA computation func.
+// new_func_name: new function name for rewritten XLA computation func.
+// host_compute_core: mapping from outside compilation cluster name to XLA
+//   device assignment.
+// fld: FunctionLibraryDefinition object.
+// host_graph: Graph object to store host side graph for all outside
+//   compilations within this XLA computation func. If there is no outside
+//   compilation, it will be empty.
+// shape_inference_graphs: a list of outside compilation shape inference
+//   function names. These functions need to be rewritten later.
+// has_outside_compilation: a bool indicating whether this function has any
+//   outside compilation nodes.
+Status ExtractOutsideCompilationForFunction(
+    const string& xla_cluster_attr_name,
+    const string& outside_compilation_attr_name, const string& xla_cluster_name,
+    const NameAttrList& func_name_attrs, const string& new_func_name,
+    const string& host_graph_func_name,
+    const std::map<string, int>& host_compute_core, FunctionLibraryRuntime* flr,
+    FunctionLibraryDefinition* fld, std::vector<string>* shape_inference_graphs,
+    bool* has_outside_compilation);
+
+// Rewrites XLA computation in `clusters` to replace outside compilation nodes
+// with XlaHostCompute, and moves those outside compilations into `g`. If shapes
+// of outside compilation outputs cannot be determined now, we will store shape
+// inference graph into `fld`.
+Status ExtractOutsideCompilation(
+    const string& xla_cluster_attr_name,
+    const string& outside_compilation_attr_name,
+    const std::unordered_map<string, XlaClusterInfo>& clusters, Graph* g,
+    FunctionLibraryRuntime* flr, FunctionLibraryDefinition* fld,
+    bool* modified);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_EXTRACT_OUTSIDE_COMPILATION_PASS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/flags.h

@@ -0,0 +1,357 @@
+/* Copyright 2017 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_FLAGS_H_
+#define TENSORFLOW_COMPILER_JIT_FLAGS_H_
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/types/optional.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/util/command_line_flags.h"
+
+namespace tensorflow {
+
+struct XlaAutoJitFlag {
+  // Control compilation of operators into XLA computations on CPU and GPU
+  // devices.  0 = use ConfigProto setting; -1 = off; 1 = on for things very
+  // likely to be improved; 2 = on for everything.
+  //
+  // If all non-CPU ops in the graph being optimized are placed on a single GPU
+  // and there is at least one node placed on that GPU then
+  // `optimization_level_single_gpu` applies.  Otherwise
+  // `optimization_level_general` applies.
+  //
+  // Experimental.
+  int32 optimization_level_single_gpu;
+  int32 optimization_level_general;
+};
+
+// Sets the xla_auto_jit_flag based on the given flag string. Supported syntax
+// is:
+// <number>: sets general and single_gpu setting to the provided number.
+// single-gpu(<number>): sets the single_gpu setting to the provided number.
+bool SetXlaAutoJitFlagFromFlagString(const string& value);
+
+// Flags associated with the XLA bridge's mark_for_compilation_pass module.
+struct MarkForCompilationPassFlags {
+  XlaAutoJitFlag xla_auto_jit_flag;
+
+  // Minimum number of operators in an XLA compilation. Ignored for operators
+  // placed on an XLA device or operators explicitly marked for compilation.
+  int32 tf_xla_min_cluster_size;
+
+  // Maximum number of operators in an XLA compilation.
+  int32 tf_xla_max_cluster_size;
+
+  // If non-empty, limit XLA clustering to the following TF operations.
+  string tf_xla_ops_to_cluster;
+
+  // If non-empty, remove following operations from XLA clustering excludelist.
+  string tf_xla_cluster_exclude_ops;
+
+  // Dump graphs during XLA compilation.
+  bool tf_xla_clustering_debug;
+
+  // Enables global JIT compilation for CPU via SessionOptions.
+  bool tf_xla_cpu_global_jit;
+
+  // "Compiler fuel" for clustering.  Only this many ops will be marked as
+  // eligible for clustering.
+  int64_t tf_xla_clustering_fuel;
+
+  // If tf_xla_disable_deadness_safety_checks_for_debugging is set to true then
+  // we do not do deadness related safety checks.  This is unsound in general,
+  // but can be used as a debugging aid.
+  bool tf_xla_disable_deadness_safety_checks_for_debugging;
+
+  // If tf_xla_disable_resource_variable_safety_checks_for_debugging is set to
+  // true then we do not do safety checks to preserve TensorFlow's resource
+  // variable concurrency semantics.  This is unsound in general, but can be
+  // used as a debugging aid.
+  bool tf_xla_disable_resource_variable_safety_checks_for_debugging;
+
+  // If true names of clustered operations will be computed deterministically
+  // so that they remain stable from run to run of auto clusteing.
+  bool tf_xla_deterministic_cluster_names;
+
+  // If non-empty, JIT-compiled executables are saved to and loaded from the
+  // specified file system directory path.
+  std::string tf_xla_persistent_cache_directory;
+
+  // If non-empty, the persistent cache will only be used for the specified
+  // devices (comma separated). Each device type should be able to be converted
+  // to `DeviceType`.
+  std::string tf_xla_persistent_cache_device_types;
+
+  bool tf_xla_persistent_cache_read_only;
+
+  // If true, entries loaded into the XLA compile cache will not have their
+  // signatures checked strictly. This should generally not be disabled except
+  // for debugging. Defaults to false.
+  bool tf_xla_disable_strict_signature_checks;
+
+  // Specifies the persistance cache prefix. Default is "xla_compile_cache"
+  string tf_xla_persistent_cache_prefix;
+};
+
+// Flags associated with XLA Sparse Core.
+struct XlaSparseCoreFlags {
+  // Max level of division to split input data into minibatches.
+  int tf_xla_sparse_core_minibatch_max_division_level;
+
+  // Disable table stacking for all the tables passed to the SparseCore
+  // mid level API.
+  bool tf_xla_sparse_core_disable_table_stacking;
+
+  // If non-zero, limits the size of the activations for a given table to
+  // be below these many bytes.
+  int64_t tf_xla_sparse_core_stacking_mem_limit_bytes;
+
+  // If non-zero, limits the size of any table shard to be below these
+  // many bytes.
+  int64_t tf_xla_sparse_core_stacking_table_shard_limit_bytes;
+};
+
+// Flags associated with the XLA bridge's xla_device module.
+struct XlaDeviceFlags {
+  // Switch the CPU device into "on-demand" mode, where instead of
+  // auto-clustering ops are compiled one by one just-in-time.
+  // Enabling this mode by a legacy flag is a temporary mechanism. When this
+  // feature is battle-tested, we will switch this to be a session option.
+  bool tf_xla_compile_on_demand;
+
+  // Enables "XLA" devices if this flag is set.
+  bool tf_xla_enable_xla_devices;
+};
+
+// Flags common to the _Xla* ops and their kernels.
+struct XlaOpsCommonFlags {
+  // If true, _XlaCompile always refuses to compile the cluster, which means the
+  // XLA clusters always run in the TF executor.  Defaults to false.
+  bool tf_xla_always_defer_compilation;
+  // If true, _XlaCompile compiles the cluster asynchronously with respect to
+  // the main execution. The fallback path is taken while compilation happens.
+  bool tf_xla_async_compilation;
+
+  class PjRtForSingleDeviceCompilationRollout {
+   public:
+    // Allow using Device API (PjRt) for `device_type` in the XlaLaunch op.
+    // Please note that `enabled_for_xla_launch_` needs to be true in addition
+    // to the `device_type` being allowed in order to use the Device API for
+    // single device compilation and execution in the XlaLaunch op.
+    void AllowForDeviceInXlaLaunch(const DeviceType& device_type) {
+      xla_launch_allowed_devices_.insert(device_type.type_string());
+    }
+
+    bool IsEnabledInXlaLaunchForDevice(const DeviceType& device_type) const {
+      if (!enabled_for_gpu_ && device_type.type_string() == "GPU") return false;
+      return enabled_for_all_ ||
+             (enabled_for_xla_launch_ &&
+              xla_launch_allowed_devices_.contains(device_type.type_string()));
+    }
+
+    // Allow using Device API (PjRt) for `device_type` in the XlaCompileOnDemand
+    // op. Please note that `enabled_for_compile_on_demand_` needs to be true in
+    // addition to the `device_type` being allowed in order to use the Device
+    // API for single device compilation and execution in the XlaCompileOnDemand
+    // op.
+    void AllowForDeviceInXlaCompileOnDemand(const DeviceType& device_type) {
+      xla_compile_on_demand_allowed_devices_.insert(device_type.type_string());
+    }
+
+    bool IsEnabledInXlaCompileOnDemandForDevice(
+        const DeviceType& device_type) const {
+      if (!enabled_for_gpu_ && device_type.type_string() == "GPU") return false;
+      return enabled_for_all_ ||
+             (enabled_for_compile_on_demand_ &&
+              xla_compile_on_demand_allowed_devices_.contains(
+                  device_type.type_string()));
+    }
+
+    // Allow using Device API (PjRt) for `device_type` in the XlaCompile and
+    // XlaRun ops. Please note that `enabled_for_compile_and_run_` needs to be
+    // true in addition to the `device_type` being allowed in order to use the
+    // Device API for single device compilation and execution in the XlaCompile
+    // and XlaRun ops.
+    void AllowForDeviceInXlaCompileAndRun(const DeviceType& device_type) {
+      xla_compile_and_run_allowed_devices_.insert(device_type.type_string());
+    }
+
+    bool IsEnabledInXlaCompileAndRunForDevice(
+        const DeviceType& device_type) const {
+      if (!enabled_for_gpu_ && device_type.type_string() == "GPU") return false;
+      return enabled_for_all_ || (enabled_for_compile_and_run_ &&
+                                  xla_compile_and_run_allowed_devices_.contains(
+                                      device_type.type_string()));
+    }
+
+    bool IsEnabledForGpu() const { return enabled_for_gpu_; }
+
+    // If true, uses Device API (PjRt) for single device compilation and
+    // execution of functions marked for JIT compilation i.e. jit_compile=True.
+    // Defaults to false.
+    bool enabled_for_xla_launch_;
+
+    // If true, uses Device API (PjRt) for compiling and executing ops one by
+    // one in "on-demand" mode. Defaults to false.
+    bool enabled_for_compile_on_demand_;
+
+    // If true, uses Device API (PjRt) for compilation and execution when
+    // auto-clustering is enabled. Defaults to false.
+    bool enabled_for_compile_and_run_;
+
+    // If true, uses Device API (PjRt) for compilation and execution everywhere
+    // i.e. for functions marked for JIT compilation, for ops in "on-demand"
+    // mode and auto-clustering. Defaults to false.
+    //
+    // Note that this flag can be overridden by device flag like
+    // `enabled_for_gpu_` below.
+    bool enabled_for_all_;
+
+    // If true, enable Device API (PjRt) for TF GPU device. This is a helper
+    // flag so that individual tests can turn on PjRt for GPU specifically.
+    // Once the rollout to GPU is complete, this flag can be deprecated.
+    bool enabled_for_gpu_;
+
+   private:
+    // Devices for which using Device API (PjRt) is allowed in the XlaLaunch op.
+    // This can only be modified programmatically.
+    absl::flat_hash_set<std::string> xla_launch_allowed_devices_;
+    // Devices for which using Device API (PjRt) is allowed in the
+    // XlaCompileOnDemand op. This can only be modified programmatically.
+    absl::flat_hash_set<std::string> xla_compile_on_demand_allowed_devices_;
+    // Devices for which using Device API (PjRt) is allowed in the
+    // XlaCompile and XlaRun ops. This can only be modified programmatically.
+    absl::flat_hash_set<std::string> xla_compile_and_run_allowed_devices_;
+  } tf_xla_use_device_api;
+};
+
+// Flags for the XlaCallModule kernel.
+struct XlaCallModuleFlags {
+  // Used by XlaCallModuleOp to specify safety checks to disable.
+  absl::flat_hash_set<std::string> disabled_checks;
+};
+
+// Flags for the build_xla_ops pass.
+struct BuildXlaOpsPassFlags {
+  // Enables lazy compilation for TF/XLA (only when auto-clustering) if true.
+  // Defaults to true.
+  bool tf_xla_enable_lazy_compilation;
+
+  // If true then insert Print nodes to print out values produced by XLA
+  // clusters.  Useful for debugging.
+  bool tf_xla_print_cluster_outputs;
+
+  // If true, insert CheckNumerics nodes for every floating point typed input to
+  // an XLA cluster.
+  bool tf_xla_check_cluster_input_numerics;
+
+  // If true, insert CheckNumerics nodes for every floating point typed output
+  // from an XLA cluster.
+  bool tf_xla_check_cluster_output_numerics;
+
+  // Disables all constant folding. The primary use for this is for testing to
+  // guarantee that tests are run on XLA and not on TF's CPU implementation.
+  bool tf_xla_disable_constant_folding;
+
+  // Disables full embedding pipelining when true. Instead, strict SparseCore
+  // TensorCore sequencing will be used.
+  bool tf_xla_disable_full_embedding_pipelining;
+
+  // Force the WhileOps in embedding_pipelining and embedding_sequencing to use
+  // this many parallel_iterations
+  int tf_xla_embedding_parallel_iterations;
+};
+
+// Flags for common MLIR configurations.
+struct MlirCommonFlags {
+  ConfigProto::Experimental::MlirBridgeRollout tf_mlir_enable_mlir_bridge;
+
+  bool tf_mlir_enable_merge_control_flow_pass;
+  bool tf_mlir_enable_convert_control_to_data_outputs_pass;
+  bool tf_mlir_enable_strict_clusters;
+  bool tf_mlir_enable_generic_outside_compilation;
+  bool tf_mlir_enable_tpu_variable_runtime_reformatting_pass;
+};
+
+// Flags for the JitRt pipeline -- see tf_jitrt_pipeline.h for details.
+struct JitRtFlags {
+  bool always_specialize;
+  bool cost_driven_async_parallel_for;
+
+  // Enables tracking of the "live" JitRt queries to, on a crash, identify the
+  // "query of death". See TfJitRtQueryOfDeathLogger.
+  bool log_query_of_death;
+
+  // Enable vectorization, which requires tiling and peeling on different ops.
+  bool vectorize;
+
+  // Enables crash reproducer for JitRt MLIR pass manager.
+  bool enable_crash_reproducer;
+};
+
+// Return a pointer to the DumpGraphFlags struct;
+// repeated calls return the same pointer.
+// This should be called only after Flags::Parse() has returned.
+
+// Getters for flags structs defined above.  The first call to any of these
+// parses TF_XLA_FLAGS for all of them.  Those functions which return a pointer
+// always return the same pointer.
+MarkForCompilationPassFlags* GetMarkForCompilationPassFlags();
+BuildXlaOpsPassFlags* GetBuildXlaOpsPassFlags();
+XlaSparseCoreFlags* GetXlaSparseCoreFlags();
+XlaDeviceFlags* GetXlaDeviceFlags();
+XlaOpsCommonFlags* GetXlaOpsCommonFlags();
+XlaCallModuleFlags* GetXlaCallModuleFlags();
+
+MlirCommonFlags* GetMlirCommonFlags();
+
+void ResetJitCompilerFlags();
+
+const JitRtFlags& GetJitRtFlags();
+
+// Returns the effective MLIR bridge rollout state based on the flags and the
+// optional configuration.
+ConfigProto::Experimental::MlirBridgeRollout GetMlirBridgeRolloutState(
+    std::optional<const ConfigProto> config_proto);
+
+// Appends the flag definitions associated with
+// MarkForCompilationPassFlags/DumpGraphFlags to `flag_list`.
+//
+// Has the side-effect of parsing TF_XLA_FLAGS if that hasn't happened yet.
+void AppendMarkForCompilationPassFlags(
+    std::vector<tensorflow::Flag>* flag_list);
+
+// Disables XLA compilation, forces it to return an error message instead. Can
+// be used by a server to ensure that JIT compilation is opt-in.
+void DisableXlaCompilation();
+
+// Enables XLA compilation. Can be used with `DisableXlaCompilation` to
+// enable/disable JIT compilation at different stages.
+void EnableXlaCompilation();
+
+// Returns `false` unless `DisableXlaCompilation` was called.
+bool FailOnXlaCompilation();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_FLAGS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/jit/force_xla_constants_on_host_pass.h

@@ -0,0 +1,36 @@
+/* Copyright 2020 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_COMPILER_JIT_FORCE_XLA_CONSTANTS_ON_HOST_PASS_H_
+#define TENSORFLOW_COMPILER_JIT_FORCE_XLA_CONSTANTS_ON_HOST_PASS_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/compiler/jit/compilability_check_util.h"
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+
+namespace tensorflow {
+
+// An optimization pass which marks the constants which have to be resolved for
+// XLA compilation with `_input_hostmem`.
+class ForceXlaConstantsOnHostPass : public GraphOptimizationPass {
+ public:
+  ForceXlaConstantsOnHostPass() = default;
+
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_COMPILER_JIT_FORCE_XLA_CONSTANTS_ON_HOST_PASS_H_