diff --git a/src/App.vue b/src/App.vue
index 8e8f814..1cbf62f 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -3,7 +3,7 @@
- Primary Symbols
+ Primary Symbols
|
tf
|
diff --git a/src/meta_primary_symbol.json b/src/meta_primary_symbol.json
new file mode 100644
index 0000000..e2e029b
--- /dev/null
+++ b/src/meta_primary_symbol.json
@@ -0,0 +1 @@
+[{"name": "tf", "docs": "\nTop-level module of TensorFlow. By convention, we refer to this module as\n`tf` instead of `tensorflow`, following the common practice of importing\nTensorFlow via the command `import tensorflow as tf`.\n\nThe primary function of this module is to import all of the public TensorFlow\ninterfaces into a single place. The interfaces themselves are located in\nsub-modules, as described below.\n\nNote that the file `__init__.py` in the TensorFlow source code tree is actually\nonly a placeholder to enable test cases to run. The TensorFlow build replaces\nthis file with a file generated from [`api_template.__init__.py`](https://www.github.com/tensorflow/tensorflow/blob/master/tensorflow/api_template.__init__.py)\n", "desc": "", "type": "API"}, {"name": "tf.abs", "docs": "Computes the absolute value of a tensor.\n\n Given a tensor of integer or floating-point values, this operation returns a\n tensor of the same type, where each element contains the absolute value of the\n corresponding element in the input.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. For\n a complex number \\\\(a + bj\\\\), its absolute value is computed as\n \\\\(\\sqrt{a^2 + b^2}\\\\).\n\n For example:\n\n >>> # real number\n >>> x = tf.constant([-2.25, 3.25])\n >>> tf.abs(x)\n \n\n >>> # complex number\n >>> x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n >>> tf.abs(x)\n \n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` of the same size, type and sparsity as `x`,\n with absolute values. Note, for `complex64` or `complex128` input, the\n returned `Tensor` will be of type `float32` or `float64`, respectively.\n\n If `x` is a `SparseTensor`, returns\n `SparseTensor(x.indices, tf.math.abs(x.values, ...), x.dense_shape)`", "desc": "Computes the absolute value of a tensor.", "type": "API"}, {"name": "tf.acos", "docs": "Computes acos of x element-wise.\n\n Provided an input tensor, the `tf.math.acos` operation\n returns the inverse cosine of each element of the tensor.\n If `y = tf.math.cos(x)` then, `x = tf.math.acos(y)`.\n\n Input range is `[-1, 1]` and the output has a range of `[0, pi]`.\n\n For example:\n\n >>> x = tf.constant([1.0, -0.5, 3.4, 0.2, 0.0, -2], dtype = tf.float32)\n >>> tf.math.acos(x)\n \n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`,\n `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as x.\n ", "desc": "Computes acos of x element-wise.", "type": "API"}, {"name": "tf.acosh", "docs": "Computes inverse hyperbolic cosine of x element-wise.\n\n Given an input tensor, the function computes inverse hyperbolic cosine of every element.\n Input range is `[1, inf]`. It returns `nan` if the input lies outside the range.\n\n ```python\n x = tf.constant([-2, -0.5, 1, 1.2, 200, 10000, float(\"inf\")])\n tf.math.acosh(x) ==> [nan nan 0. 0.62236255 5.9914584 9.903487 inf]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic cosine of x element-wise.", "type": "API"}, {"name": "tf.add", "docs": "Returns x + y element-wise.\n\n Example usages below.\n\n Add a scalar and a list:\n\n >>> x = [1, 2, 3, 4, 5]\n >>> y = 1\n >>> tf.add(x, y)\n \n\n Note that binary `+` operator can be used instead:\n\n >>> x = tf.convert_to_tensor([1, 2, 3, 4, 5])\n >>> y = tf.convert_to_tensor(1)\n >>> x + y\n \n\n Add a tensor and a list of same shape:\n\n >>> x = [1, 2, 3, 4, 5]\n >>> y = tf.constant([1, 2, 3, 4, 5])\n >>> tf.add(x, y)\n \n\n **Warning**: If one of the inputs (`x` or `y`) is a tensor and the other is a\n non-tensor, the non-tensor input will adopt (or get casted to) the data type\n of the tensor input. This can potentially cause unwanted overflow or underflow\n conversion.\n\n For example,\n\n >>> x = tf.constant([1, 2], dtype=tf.int8)\n >>> y = [2**7 + 1, 2**7 + 2]\n >>> tf.add(x, y)\n \n\n When adding two input values of different shapes, `Add` follows NumPy\n broadcasting rules. The two input array shapes are compared element-wise.\n Starting with the trailing dimensions, the two dimensions either have to be\n equal or one of them needs to be `1`.\n\n For example,\n\n >>> x = np.ones(6).reshape(1, 2, 1, 3)\n >>> y = np.ones(6).reshape(2, 1, 3, 1)\n >>> tf.add(x, y).shape.as_list()\n [2, 2, 3, 3]\n\n Another example with two arrays of different dimension.\n\n >>> x = np.ones([1, 2, 1, 4])\n >>> y = np.ones([3, 4])\n >>> tf.add(x, y).shape.as_list()\n [1, 2, 3, 4]\n\n The reduction version of this elementwise operation is `tf.math.reduce_sum`\n\n Args:\n x: A `tf.Tensor`. Must be one of the following types: bfloat16, half,\n float32, float64, uint8, int8, int16, int32, int64, complex64, complex128,\n string.\n y: A `tf.Tensor`. Must have the same type as x.\n name: A name for the operation (optional)\n ", "desc": "Returns x + y element-wise.", "type": "API"}, {"name": "tf.add_n", "docs": "Adds all input tensors element-wise.\n\n `tf.math.add_n` performs the same operation as `tf.math.accumulate_n`.\n\n This op does not [broadcast](\n https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)\n its inputs. If you need broadcasting, use `tf.math.add` (or the `+` operator)\n instead.\n\n For example:\n\n >>> a = tf.constant([[3, 5], [4, 8]])\n >>> b = tf.constant([[1, 6], [2, 9]])\n >>> tf.math.add_n([a, b, a])\n \n\n Args:\n inputs: A list of `tf.Tensor` or `tf.IndexedSlices` objects, each with the\n same shape and type. `tf.IndexedSlices` objects will be converted into\n dense tensors prior to adding.\n name: A name for the operation (optional).\n\n Returns:\n A `tf.Tensor` of the same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n ", "desc": "Adds all input tensors element-wise.", "type": "API"}, {"name": "tf.AggregationMethod", "docs": "A class listing aggregation methods used to combine gradients.\n\n Computing partial derivatives can require aggregating gradient\n contributions. This class lists the various methods that can\n be used to combine gradients in the graph.\n\n The following aggregation methods are part of the stable API for\n aggregating gradients:\n\n * `ADD_N`: All of the gradient terms are summed as part of one\n operation using the \"AddN\" op (see `tf.add_n`). This\n method has the property that all gradients must be ready and\n buffered separately in memory before any aggregation is performed.\n * `DEFAULT`: The system-chosen default aggregation method.\n\n The following aggregation methods are experimental and may not\n be supported in future releases:\n\n * `EXPERIMENTAL_TREE`: Gradient terms are summed in pairs using\n the \"AddN\" op. This method of summing gradients may reduce\n performance, but it can improve memory utilization because the\n gradients can be released earlier.\n\n ", "desc": "A class listing aggregation methods used to combine gradients.", "type": "API"}, {"name": "tf.argmax", "docs": "Returns the index with the largest value across axes of a tensor.\n\n In case of identity returns the smallest index.\n\n For example:\n\n >>> A = tf.constant([2, 20, 30, 3, 6])\n >>> tf.math.argmax(A) # A[2] is maximum in tensor A\n \n >>> B = tf.constant([[2, 20, 30, 3, 6], [3, 11, 16, 1, 8],\n ... [14, 45, 23, 5, 27]])\n >>> tf.math.argmax(B, 0)\n \n >>> tf.math.argmax(B, 1)\n \n >>> C = tf.constant([0, 0, 0, 0])\n >>> tf.math.argmax(C) # Returns smallest index in case of ties\n \n\n Args:\n input: A `Tensor`.\n axis: An integer, the axis to reduce across. Default to 0.\n output_type: An optional output dtype (`tf.int32` or `tf.int64`). Defaults\n to `tf.int64`.\n name: An optional name for the operation.\n\n Returns:\n A `Tensor` of type `output_type`.\n ", "desc": "Returns the index with the largest value across axes of a tensor.", "type": "API"}, {"name": "tf.argmin", "docs": "Returns the index with the smallest value across axes of a tensor.\n\n Returns the smallest index in case of ties.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`,\n `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`,\n `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to\n `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n\n Usage:\n ```python\n import tensorflow as tf\n a = [1, 10, 26.9, 2.8, 166.32, 62.3]\n b = tf.math.argmin(input = a)\n c = tf.keras.backend.eval(b)\n # c = 0\n # here a[0] = 1 which is the smallest element of a across axis 0\n ```\n ", "desc": "Returns the index with the smallest value across axes of a tensor.", "type": "API"}, {"name": "tf.argsort", "docs": "Returns the indices of a tensor that give its sorted order along an axis.\n\n >>> values = [1, 10, 26.9, 2.8, 166.32, 62.3]\n >>> sort_order = tf.argsort(values)\n >>> sort_order.numpy()\n array([0, 3, 1, 2, 5, 4], dtype=int32)\n\n For a 1D tensor:\n\n >>> sorted = tf.gather(values, sort_order)\n >>> assert tf.reduce_all(sorted == tf.sort(values))\n\n For higher dimensions, the output has the same shape as\n `values`, but along the given axis, values represent the index of the sorted\n element in that slice of the tensor at the given position.\n\n >>> mat = [[30,20,10],\n ... [20,10,30],\n ... [10,30,20]]\n >>> indices = tf.argsort(mat)\n >>> indices.numpy()\n array([[2, 1, 0],\n [1, 0, 2],\n [0, 2, 1]], dtype=int32)\n\n If `axis=-1` these indices can be used to apply a sort using `tf.gather`:\n\n >>> tf.gather(mat, indices, batch_dims=-1).numpy()\n array([[10, 20, 30],\n [10, 20, 30],\n [10, 20, 30]], dtype=int32)\n\n See also:\n\n * `tf.sort`: Sort along an axis.\n * `tf.math.top_k`: A partial sort that returns a fixed number of top values\n and corresponding indices.\n\n Args:\n values: 1-D or higher **numeric** `Tensor`.\n axis: The axis along which to sort. The default is -1, which sorts the last\n axis.\n direction: The direction in which to sort the values (`'ASCENDING'` or\n `'DESCENDING'`).\n stable: If True, equal elements in the original tensor will not be\n re-ordered in the returned order. Unstable sort is not yet implemented,\n but will eventually be the default for performance reasons. If you require\n a stable order, pass `stable=True` for forwards compatibility.\n name: Optional name for the operation.\n\n Returns:\n An int32 `Tensor` with the same shape as `values`. The indices that would\n sort each slice of the given `values` along the given `axis`.\n\n Raises:\n ValueError: If axis is not a constant scalar, or the direction is invalid.\n tf.errors.InvalidArgumentError: If the `values.dtype` is not a `float` or\n `int` type.\n ", "desc": "Returns the indices of a tensor that give its sorted order along an axis.", "type": "API"}, {"name": "tf.as_dtype", "docs": "Converts the given `type_value` to a `DType`.\n\n Note: `DType` values are interned. When passed a new `DType` object,\n `as_dtype` always returns the interned value.\n\n Args:\n type_value: A value that can be converted to a `tf.DType` object. This may\n currently be a `tf.DType` object, a [`DataType`\n enum](https://www.tensorflow.org/code/tensorflow/core/framework/types.proto),\n a string type name, or a [`numpy.dtype`](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html).\n\n Returns:\n A `DType` corresponding to `type_value`.\n\n Raises:\n TypeError: If `type_value` cannot be converted to a `DType`.\n ", "desc": "Converts the given `type_value` to a `DType`.", "type": "API"}, {"name": "tf.as_string", "docs": "Converts each entry in the given tensor to strings.\n\n Supports many numeric types and boolean.\n\n For Unicode, see the\n [https://www.tensorflow.org/tutorials/representation/unicode](Working with Unicode text)\n tutorial.\n\n Examples:\n\n >>> tf.strings.as_string([3, 2])\n \n >>> tf.strings.as_string([3.1415926, 2.71828], precision=2).numpy()\n array([b'3.14', b'2.72'], dtype=object)\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `complex64`, `complex128`, `bool`, `variant`.\n precision: An optional `int`. Defaults to `-1`.\n The post-decimal precision to use for floating point numbers.\n Only used if precision > -1.\n scientific: An optional `bool`. Defaults to `False`.\n Use scientific notation for floating point numbers.\n shortest: An optional `bool`. Defaults to `False`.\n Use shortest representation (either scientific or standard) for\n floating point numbers.\n width: An optional `int`. Defaults to `-1`.\n Pad pre-decimal numbers to this width.\n Applies to both floating point and integer numbers.\n Only used if width > -1.\n fill: An optional `string`. Defaults to `\"\"`.\n The value to pad if width > -1. If empty, pads with spaces.\n Another typical value is '0'. String cannot be longer than 1 character.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Converts each entry in the given tensor to strings.", "type": "API"}, {"name": "tf.asin", "docs": "Computes the trignometric inverse sine of x element-wise.\n\n The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that\n if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.\n\n **Note**: The output of `tf.math.asin` will lie within the invertible range\n of sine, i.e [-pi/2, pi/2].\n\n For example:\n\n ```python\n # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]\n x = tf.constant([1.047, 0.785])\n y = tf.math.sin(x) # [0.8659266, 0.7068252]\n\n tf.math.asin(y) # [1.047, 0.785] = x\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes the trignometric inverse sine of x element-wise.", "type": "API"}, {"name": "tf.asinh", "docs": "Computes inverse hyperbolic sine of x element-wise.\n\n Given an input tensor, this function computes inverse hyperbolic sine\n for every element in the tensor. Both input and output has a range of\n `[-inf, inf]`.\n\n ```python\n x = tf.constant([-float(\"inf\"), -2, -0.5, 1, 1.2, 200, 10000, float(\"inf\")])\n tf.math.asinh(x) ==> [-inf -1.4436355 -0.4812118 0.8813736 1.0159732 5.991471 9.903487 inf]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic sine of x element-wise.", "type": "API"}, {"name": "tf.Assert", "docs": "Asserts that the given condition is true.\n\nIf `condition` evaluates to false, print the list of tensors in `data`.\n`summarize` determines how many entries of the tensors to print.\n\nArgs:\n condition: The condition to evaluate.\n data: The tensors to print out when condition is false.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional).\n\nReturns:\n assert_op: An `Operation` that, when executed, raises a\n `tf.errors.InvalidArgumentError` if `condition` is not true.\n @compatibility(eager)\n returns None\n @end_compatibility\n\nRaises:\n @compatibility(TF1)\n When in TF V1 mode (that is, outside `tf.function`) Assert needs a control\n dependency on the output to ensure the assertion executes:\n\n```python\n# Ensure maximum element of x is smaller or equal to 1\nassert_op = tf.Assert(tf.less_equal(tf.reduce_max(x), 1.), [x])\nwith tf.control_dependencies([assert_op]):\n ... code using x ...\n```\n\n @end_compatibility\n\n\nNote: The output of this function should be used. If it is not, a warning will be logged or an error may be raised. To mark the output as used, call its .mark_used() method.", "desc": "Asserts that the given condition is true.", "type": "API"}, {"name": "tf.assert_equal", "docs": "Assert the condition `x == y` holds element-wise.\n\n This Op checks that `x[i] == y[i]` holds for every pair of (possibly\n broadcast) elements of `x` and `y`. If both `x` and `y` are empty, this is\n trivially satisfied.\n\n If `x` and `y` are not equal, `message`, as well as the first `summarize`\n entries of `x` and `y` are printed, and `InvalidArgumentError` is raised.\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n message: A string to prefix to the default message.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional). Defaults to \"assert_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x == y` is False. This can be\n used with `tf.control_dependencies` inside of `tf.function`s to block\n followup computation until the check has executed.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x == y` is False. The check can be performed immediately during eager\n execution or if `x` and `y` are statically known.\n ", "desc": "Assert the condition `x == y` holds element-wise.", "type": "API"}, {"name": "tf.assert_greater", "docs": "Assert the condition `x > y` holds element-wise.\n\n This Op checks that `x[i] > y[i]` holds for every pair of (possibly\n broadcast) elements of `x` and `y`. If both `x` and `y` are empty, this is\n trivially satisfied.\n\n If `x` is not greater than `y` element-wise, `message`, as well as the first\n `summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is\n raised.\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n message: A string to prefix to the default message.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional). Defaults to \"assert_greater\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x > y` is False. This can be\n used with `tf.control_dependencies` inside of `tf.function`s to block\n followup computation until the check has executed.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x > y` is False. The check can be performed immediately during eager\n execution or if `x` and `y` are statically known.\n ", "desc": "Assert the condition `x > y` holds element-wise.", "type": "API"}, {"name": "tf.assert_less", "docs": "Assert the condition `x < y` holds element-wise.\n\n This Op checks that `x[i] < y[i]` holds for every pair of (possibly\n broadcast) elements of `x` and `y`. If both `x` and `y` are empty, this is\n trivially satisfied.\n\n If `x` is not less than `y` element-wise, `message`, as well as the first\n `summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is\n raised.\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n message: A string to prefix to the default message.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional). Defaults to \"assert_less\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x < y` is False.\n This can be used with `tf.control_dependencies` inside of `tf.function`s\n to block followup computation until the check has executed.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x < y` is False. The check can be performed immediately during eager\n execution or if `x` and `y` are statically known.\n ", "desc": "Assert the condition `x < y` holds element-wise.", "type": "API"}, {"name": "tf.assert_rank", "docs": "Assert that `x` has rank equal to `rank`.\n\n This Op checks that the rank of `x` is equal to `rank`.\n\n If `x` has a different rank, `message`, as well as the shape of `x` are\n printed, and `InvalidArgumentError` is raised.\n\n Args:\n x: `Tensor`.\n rank: Scalar integer `Tensor`.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to\n \"assert_rank\".\n\n Returns:\n Op raising `InvalidArgumentError` unless `x` has specified rank.\n If static checks determine `x` has correct rank, a `no_op` is returned.\n This can be used with `tf.control_dependencies` inside of `tf.function`s\n to block followup computation until the check has executed.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x` does not have rank `rank`. The check can be performed immediately\n during eager execution or if the shape of `x` is statically known.\n ", "desc": "Assert that `x` has rank equal to `rank`.", "type": "API"}, {"name": "tf.atan", "docs": "Computes the trignometric inverse tangent of x element-wise.\n\n The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that\n if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.\n\n **Note**: The output of `tf.math.atan` will lie within the invertible range\n of tan, i.e (-pi/2, pi/2).\n\n For example:\n\n ```python\n # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]\n x = tf.constant([1.047, 0.785])\n y = tf.math.tan(x) # [1.731261, 0.99920404]\n\n tf.math.atan(y) # [1.047, 0.785] = x\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes the trignometric inverse tangent of x element-wise.", "type": "API"}, {"name": "tf.atan2", "docs": "Computes arctangent of `y/x` element-wise, respecting signs of the arguments.\n\n This is the angle \\\\( \\theta \\in [-\\pi, \\pi] \\\\) such that\n \\\\[ x = r \\cos(\\theta) \\\\]\n and\n \\\\[ y = r \\sin(\\theta) \\\\]\n where \\\\(r = \\sqrt{x^2 + y^2} \\\\).\n\n For example:\n\n >>> x = [1., 1.]\n >>> y = [1., -1.]\n >>> print((tf.math.atan2(y,x) * (180 / np.pi)).numpy())\n [ 45. -45.]\n\n Args:\n y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n x: A `Tensor`. Must have the same type as `y`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `y`.\n ", "desc": "Computes arctangent of `y/x` element-wise, respecting signs of the arguments.", "type": "API"}, {"name": "tf.atanh", "docs": "Computes inverse hyperbolic tangent of x element-wise.\n\n Given an input tensor, this function computes inverse hyperbolic tangent\n for every element in the tensor. Input range is `[-1,1]` and output range is\n `[-inf, inf]`. If input is `-1`, output will be `-inf` and if the\n input is `1`, output will be `inf`. Values outside the range will have\n `nan` as output.\n\n ```python\n x = tf.constant([-float(\"inf\"), -1, -0.5, 1, 0, 0.5, 10, float(\"inf\")])\n tf.math.atanh(x) ==> [nan -inf -0.54930615 inf 0. 0.54930615 nan nan]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic tangent of x element-wise.", "type": "API"}, {"name": "tf.audio", "docs": "Public API for tf.audio namespace.\n", "desc": "Public API for tf.audio namespace.", "type": "API"}, {"name": "tf.audio.decode_wav", "docs": "Decode a 16-bit PCM WAV file to a float tensor.\n\n The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.\n\n When desired_channels is set, if the input contains fewer channels than this\n then the last channel will be duplicated to give the requested number, else if\n the input has more channels than requested then the additional channels will be\n ignored.\n\n If desired_samples is set, then the audio will be cropped or padded with zeroes\n to the requested length.\n\n The first output contains a Tensor with the content of the audio samples. The\n lowest dimension will be the number of channels, and the second will be the\n number of samples. For example, a ten-sample-long stereo WAV file should give an\n output shape of [10, 2].\n\n Args:\n contents: A `Tensor` of type `string`.\n The WAV-encoded audio, usually from a file.\n desired_channels: An optional `int`. Defaults to `-1`.\n Number of sample channels wanted.\n desired_samples: An optional `int`. Defaults to `-1`.\n Length of audio requested.\n name: A name for the operation (optional).\n\n Returns:\n A tuple of `Tensor` objects (audio, sample_rate).\n\n audio: A `Tensor` of type `float32`.\n sample_rate: A `Tensor` of type `int32`.\n ", "desc": "Decode a 16-bit PCM WAV file to a float tensor.", "type": "API"}, {"name": "tf.audio.encode_wav", "docs": "Encode audio data using the WAV file format.\n\n This operation will generate a string suitable to be saved out to create a .wav\n audio file. It will be encoded in the 16-bit PCM format. It takes in float\n values in the range -1.0f to 1.0f, and any outside that value will be clamped to\n that range.\n\n `audio` is a 2-D float Tensor of shape `[length, channels]`.\n `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).\n\n Args:\n audio: A `Tensor` of type `float32`. 2-D with shape `[length, channels]`.\n sample_rate: A `Tensor` of type `int32`.\n Scalar containing the sample frequency.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Encode audio data using the WAV file format.", "type": "API"}, {"name": "tf.autodiff", "docs": "Public API for tf.autodiff namespace.\n", "desc": "Public API for tf.autodiff namespace.", "type": "API"}, {"name": "tf.autodiff.ForwardAccumulator", "docs": "Computes Jacobian-vector products (\"JVP\"s) using forward-mode autodiff.\n\n Compare to `tf.GradientTape` which computes vector-Jacobian products (\"VJP\"s)\n using reverse-mode autodiff (backprop). Reverse mode is more attractive when\n computing gradients of a scalar-valued function with respect to many inputs\n (e.g. a neural network with many parameters and a scalar loss). Forward mode\n works best on functions with many outputs and few inputs. Since it does not\n hold on to intermediate activations, it is much more memory efficient than\n backprop where it is applicable.\n\n Consider a simple linear regression:\n\n >>> x = tf.constant([[2.0, 3.0], [1.0, 4.0]])\n >>> targets = tf.constant([[1.], [-1.]])\n >>> dense = tf.keras.layers.Dense(1)\n >>> dense.build([None, 2])\n >>> with tf.autodiff.ForwardAccumulator(\n ... primals=dense.kernel,\n ... tangents=tf.constant([[1.], [0.]])) as acc:\n ... loss = tf.reduce_sum((dense(x) - targets) ** 2.)\n >>> acc.jvp(loss)\n \n\n The example has two variables containing parameters, `dense.kernel` (2\n parameters) and `dense.bias` (1 parameter). Considering the training data `x`\n as a constant, this means the Jacobian matrix for the function mapping from\n parameters to loss has one row and three columns.\n\n With forwardprop, we specify a length-three vector in advance which multiplies\n the Jacobian. The `primals` constructor argument is the parameter (a\n `tf.Tensor` or `tf.Variable`) we're specifying a vector for, and the\n `tangents` argument is the \"vector\" in Jacobian-vector product. If our goal is\n to compute the entire Jacobian matrix, forwardprop computes one column at a\n time while backprop computes one row at a time. Since the Jacobian in the\n linear regression example has only one row, backprop requires fewer\n invocations:\n\n >>> x = tf.constant([[2.0, 3.0], [1.0, 4.0]])\n >>> targets = tf.constant([[1.], [-1.]])\n >>> dense = tf.keras.layers.Dense(1)\n >>> dense.build([None, 2])\n >>> loss_fn = lambda: tf.reduce_sum((dense(x) - targets) ** 2.)\n >>> kernel_fprop = []\n >>> with tf.autodiff.ForwardAccumulator(\n ... dense.kernel, tf.constant([[1.], [0.]])) as acc:\n ... kernel_fprop.append(acc.jvp(loss_fn()))\n >>> with tf.autodiff.ForwardAccumulator(\n ... dense.kernel, tf.constant([[0.], [1.]])) as acc:\n ... kernel_fprop.append(acc.jvp(loss_fn()))\n >>> with tf.autodiff.ForwardAccumulator(dense.bias, tf.constant([1.])) as acc:\n ... bias_fprop = acc.jvp(loss_fn())\n >>> with tf.GradientTape() as tape:\n ... loss = loss_fn()\n >>> kernel_grad, bias_grad = tape.gradient(loss, (dense.kernel, dense.bias))\n >>> np.testing.assert_allclose(\n ... kernel_grad, tf.stack(kernel_fprop)[:, tf.newaxis])\n >>> np.testing.assert_allclose(bias_grad, bias_fprop[tf.newaxis])\n\n Implicit in the `tape.gradient` call is a length-one vector which\n left-multiplies the Jacobian, a vector-Jacobian product.\n\n `ForwardAccumulator` maintains JVPs corresponding primal tensors it is\n watching, derived from the original `primals` specified in the constructor. As\n soon as a primal tensor is deleted, `ForwardAccumulator` deletes the\n corresponding JVP.\n\n `acc.jvp(x)` retrieves `acc`'s JVP corresponding to the primal tensor `x`. It\n does not perform any computation. `acc.jvp` calls can be repeated as long as\n `acc` is accessible, whether the context manager is active or not. New JVPs\n are only computed while the context manager is active.\n\n Note that `ForwardAccumulator`s are always applied in the order their context\n managers were entered, so inner accumulators will not see JVP computation from\n outer accumulators. Take higher-order JVPs from outer accumulators:\n\n >>> primal = tf.constant(1.1)\n >>> with tf.autodiff.ForwardAccumulator(primal, tf.constant(1.)) as outer:\n ... with tf.autodiff.ForwardAccumulator(primal, tf.constant(1.)) as inner:\n ... primal_out = primal ** tf.constant(3.5)\n >>> inner_jvp = inner.jvp(primal_out)\n >>> inner_jvp # 3.5 * 1.1 ** 2.5\n \n >>> outer.jvp(inner_jvp) # 3.5 * 2.5 * 1.1 ** 1.5\n \n\n Reversing the collection in the last line to instead retrieve\n `inner.jvp(outer.jvp(primal_out))` will not work.\n\n Strict nesting also applies to combinations of `ForwardAccumulator` and\n `tf.GradientTape`. More deeply nested `GradientTape` objects will ignore the\n products of outer `ForwardAccumulator` objects. This allows (for example)\n memory-efficient forward-over-backward computation of Hessian-vector products,\n where the inner `GradientTape` would otherwise hold on to all intermediate\n JVPs:\n\n >>> v = tf.Variable([1., 2.])\n >>> with tf.autodiff.ForwardAccumulator(\n ... v,\n ... # The \"vector\" in Hessian-vector product.\n ... tf.constant([1., 0.])) as acc:\n ... with tf.GradientTape() as tape:\n ... y = tf.reduce_sum(v ** 3.)\n ... backward = tape.gradient(y, v)\n >>> backward # gradient from backprop\n \n >>> acc.jvp(backward) # forward-over-backward Hessian-vector product\n \n ", "desc": "Computes Jacobian-vector products (\"JVP\"s) using forward-mode autodiff.", "type": "API"}, {"name": "tf.autodiff.GradientTape", "docs": "Record operations for automatic differentiation.\n\n Operations are recorded if they are executed within this context manager and\n at least one of their inputs is being \"watched\".\n\n Trainable variables (created by `tf.Variable` or `tf.compat.v1.get_variable`,\n where `trainable=True` is default in both cases) are automatically watched.\n Tensors can be manually watched by invoking the `watch` method on this context\n manager.\n\n For example, consider the function `y = x * x`. The gradient at `x = 3.0` can\n be computed as:\n\n >>> x = tf.constant(3.0)\n >>> with tf.GradientTape() as g:\n ... g.watch(x)\n ... y = x * x\n >>> dy_dx = g.gradient(y, x)\n >>> print(dy_dx)\n tf.Tensor(6.0, shape=(), dtype=float32)\n\n GradientTapes can be nested to compute higher-order derivatives. For example,\n\n >>> x = tf.constant(5.0)\n >>> with tf.GradientTape() as g:\n ... g.watch(x)\n ... with tf.GradientTape() as gg:\n ... gg.watch(x)\n ... y = x * x\n ... dy_dx = gg.gradient(y, x) # dy_dx = 2 * x\n >>> d2y_dx2 = g.gradient(dy_dx, x) # d2y_dx2 = 2\n >>> print(dy_dx)\n tf.Tensor(10.0, shape=(), dtype=float32)\n >>> print(d2y_dx2)\n tf.Tensor(2.0, shape=(), dtype=float32)\n\n By default, the resources held by a GradientTape are released as soon as\n GradientTape.gradient() method is called. To compute multiple gradients over\n the same computation, create a persistent gradient tape. This allows multiple\n calls to the gradient() method as resources are released when the tape object\n is garbage collected. For example:\n\n >>> x = tf.constant(3.0)\n >>> with tf.GradientTape(persistent=True) as g:\n ... g.watch(x)\n ... y = x * x\n ... z = y * y\n >>> dz_dx = g.gradient(z, x) # (4*x^3 at x = 3)\n >>> print(dz_dx)\n tf.Tensor(108.0, shape=(), dtype=float32)\n >>> dy_dx = g.gradient(y, x)\n >>> print(dy_dx)\n tf.Tensor(6.0, shape=(), dtype=float32)\n\n By default GradientTape will automatically watch any trainable variables that\n are accessed inside the context. If you want fine grained control over which\n variables are watched you can disable automatic tracking by passing\n `watch_accessed_variables=False` to the tape constructor:\n\n >>> x = tf.Variable(2.0)\n >>> w = tf.Variable(5.0)\n >>> with tf.GradientTape(\n ... watch_accessed_variables=False, persistent=True) as tape:\n ... tape.watch(x)\n ... y = x ** 2 # Gradients will be available for `x`.\n ... z = w ** 3 # No gradients will be available as `w` isn't being watched.\n >>> dy_dx = tape.gradient(y, x)\n >>> print(dy_dx)\n tf.Tensor(4.0, shape=(), dtype=float32)\n >>> # No gradients will be available as `w` isn't being watched.\n >>> dz_dw = tape.gradient(z, w)\n >>> print(dz_dw)\n None\n\n Note that when using models you should ensure that your variables exist when\n using `watch_accessed_variables=False`. Otherwise it's quite easy to make your\n first iteration not have any gradients:\n\n ```python\n a = tf.keras.layers.Dense(32)\n b = tf.keras.layers.Dense(32)\n\n with tf.GradientTape(watch_accessed_variables=False) as tape:\n tape.watch(a.variables) # Since `a.build` has not been called at this point\n # `a.variables` will return an empty list and the\n # tape will not be watching anything.\n result = b(a(inputs))\n tape.gradient(result, a.variables) # The result of this computation will be\n # a list of `None`s since a's variables\n # are not being watched.\n ```\n\n Note that only tensors with real or complex dtypes are differentiable.\n ", "desc": "Record operations for automatic differentiation.", "type": "API"}, {"name": "tf.autograph", "docs": "Conversion of eager-style Python into TensorFlow graph code.\n\nNOTE: In TensorFlow 2.0, AutoGraph is automatically applied when using\n`tf.function`. This module contains lower-level APIs for advanced use.\n\nAutoGraph transforms a subset of Python which operates on TensorFlow objects\ninto equivalent TensorFlow graph code. When executing the graph, it has the same\neffect as if you ran the original code in eager mode.\nPython code which doesn't operate on TensorFlow objects remains functionally\nunchanged, but keep in mind that `tf.function` only executes such code at trace\ntime, and generally will not be consistent with eager execution.\n\nFor more information, see the\n[AutoGraph reference documentation](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/index.md),\nand the [tf.function guide](https://www.tensorflow.org/guide/function#autograph_transformations).\n\n", "desc": "Conversion of eager-style Python into TensorFlow graph code.", "type": "API"}, {"name": "tf.autograph.experimental", "docs": "Public API for tf.autograph.experimental namespace.\n", "desc": "Public API for tf.autograph.experimental namespace.", "type": "API"}, {"name": "tf.autograph.experimental.do_not_convert", "docs": "Decorator that suppresses the conversion of a function.\n\n Args:\n func: function to decorate.\n\n Returns:\n If `func` is not None, returns a `Callable` which is equivalent to\n `func`, but is not converted by AutoGraph.\n If `func` is None, returns a decorator that, when invoked with a\n single `func` argument, returns a `Callable` equivalent to the\n above case.\n ", "desc": "Decorator that suppresses the conversion of a function.", "type": "API"}, {"name": "tf.autograph.experimental.Feature", "docs": "This enumeration represents optional conversion options.\n\n These conversion options are experimental. They are subject to change without\n notice and offer no guarantees.\n\n _Example Usage_\n\n ```python\n optionals= tf.autograph.experimental.Feature.EQUALITY_OPERATORS\n @tf.function(experimental_autograph_options=optionals)\n def f(i):\n if i == 0: # EQUALITY_OPERATORS allows the use of == here.\n tf.print('i is zero')\n ```\n\n Attributes:\n ALL: Enable all features.\n AUTO_CONTROL_DEPS: Insert of control dependencies in the generated code.\n ASSERT_STATEMENTS: Convert Tensor-dependent assert statements to tf.Assert.\n BUILTIN_FUNCTIONS: Convert builtin functions applied to Tensors to\n their TF counterparts.\n EQUALITY_OPERATORS: Whether to convert the comparison operators, like\n equality. This is soon to be deprecated as support is being added to the\n Tensor class.\n LISTS: Convert list idioms, like initializers, slices, append, etc.\n NAME_SCOPES: Insert name scopes that name ops according to context, like the\n function they were defined in.\n ", "desc": "This enumeration represents optional conversion options.", "type": "API"}, {"name": "tf.autograph.experimental.set_loop_options", "docs": "Specifies additional arguments to be passed to the enclosing while_loop.\n\n The parameters apply to and only to the immediately enclosing loop. It only\n has effect if the loop is staged as a TF while_loop; otherwise the parameters\n have no effect.\n\n Usage:\n\n >>> @tf.function(autograph=True)\n ... def f():\n ... n = 0\n ... for i in tf.range(10):\n ... tf.autograph.experimental.set_loop_options(maximum_iterations=3)\n ... n += 1\n ... return n\n\n >>> @tf.function(autograph=True)\n ... def f():\n ... v = tf.constant((0,))\n ... for i in tf.range(3):\n ... tf.autograph.experimental.set_loop_options(\n ... shape_invariants=[(v, tf.TensorShape([None]))]\n ... )\n ... v = tf.concat((v, [i]), 0)\n ... return v\n\n Also see tf.while_loop.\n\n Args:\n parallel_iterations: The maximum number of iterations allowed to run in\n parallel at any given time. Note that this does not guarantee parallel\n execution.\n swap_memory: Whether to store intermediate values needed for\n gradients on the CPU instead of GPU.\n maximum_iterations: Allows limiting the total number of iterations executed\n by the loop.\n shape_invariants: Allows controlling the argument with the same name passed\n to tf.while_loop. Unlike tf.while_loop, this is a list of\n `(tensor, shape)` pairs.\n ", "desc": "Specifies additional arguments to be passed to the enclosing while_loop.", "type": "API"}, {"name": "tf.autograph.set_verbosity", "docs": "Sets the AutoGraph verbosity level.\n\n _Debug logging in AutoGraph_\n\n More verbose logging is useful to enable when filing bug reports or doing\n more in-depth debugging.\n\n There are two means to control the logging verbosity:\n\n * The `set_verbosity` function\n\n * The `AUTOGRAPH_VERBOSITY` environment variable\n\n `set_verbosity` takes precedence over the environment variable.\n\n For example:\n\n ```python\n import os\n import tensorflow as tf\n\n os.environ['AUTOGRAPH_VERBOSITY'] = '5'\n # Verbosity is now 5\n\n tf.autograph.set_verbosity(0)\n # Verbosity is now 0\n\n os.environ['AUTOGRAPH_VERBOSITY'] = '1'\n # No effect, because set_verbosity was already called.\n ```\n\n Logs entries are output to [absl](https://abseil.io)'s\n [default output](https://abseil.io/docs/python/guides/logging),\n with `INFO` level.\n Logs can be mirrored to stdout by using the `alsologtostdout` argument.\n Mirroring is enabled by default when Python runs in interactive mode.\n\n Args:\n level: int, the verbosity level; larger values specify increased verbosity;\n 0 means no logging. When reporting bugs, it is recommended to set this\n value to a larger number, like 10.\n alsologtostdout: bool, whether to also output log messages to `sys.stdout`.\n ", "desc": "Sets the AutoGraph verbosity level.", "type": "API"}, {"name": "tf.autograph.to_code", "docs": "Returns the source code generated by AutoGraph, as a string.\n\n Example usage:\n\n >>> def f(x):\n ... if x < 0:\n ... x = -x\n ... return x\n >>> tf.autograph.to_code(f)\n \"...def tf__f(x):...\"\n\n Also see: `tf.autograph.to_graph`.\n\n Note: If a function has been decorated with `tf.function`, pass its\n underlying Python function, rather than the callable that `tf.function\n creates:\n\n >>> @tf.function\n ... def f(x):\n ... if x < 0:\n ... x = -x\n ... return x\n >>> tf.autograph.to_code(f.python_function)\n \"...def tf__f(x):...\"\n\n Args:\n entity: Python callable or class to convert.\n recursive: Whether to recursively convert any functions that the converted\n function may call.\n experimental_optional_features: `None`, a tuple of, or a single\n `tf.autograph.experimental.Feature` value.\n\n Returns:\n The converted code as string.\n ", "desc": "Returns the source code generated by AutoGraph, as a string.", "type": "API"}, {"name": "tf.autograph.to_graph", "docs": "Converts a Python entity into a TensorFlow graph.\n\n Also see: `tf.autograph.to_code`, `tf.function`.\n\n Unlike `tf.function`, `to_graph` is a low-level transpiler that converts\n Python code to TensorFlow graph code. It does not implement any caching,\n variable management or create any actual ops, and is best used where greater\n control over the generated TensorFlow graph is desired. Another difference\n from `tf.function` is that `to_graph` will not wrap the graph into a\n TensorFlow function or a Python callable. Internally, `tf.function` uses\n `to_graph`.\n\n Example usage:\n\n >>> def f(x):\n ... if x > 0:\n ... y = x * x\n ... else:\n ... y = -x\n ... return y\n ...\n >>> converted_f = to_graph(f)\n >>> x = tf.constant(2)\n >>> converted_f(x) # converted_foo is like a TensorFlow Op.\n \n\n Supported Python entities include:\n * functions\n * classes\n * object methods\n\n Functions are converted into new functions with converted code.\n\n Classes are converted by generating a new class whose methods use converted\n code.\n\n Methods are converted into unbound function that have an additional first\n argument called `self`.\n\n For a tutorial, see the\n [tf.function and AutoGraph guide](https://www.tensorflow.org/guide/function).\n For more detailed information, see the\n [AutoGraph reference documentation](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/index.md).\n\n Args:\n entity: Python callable or class to convert.\n recursive: Whether to recursively convert any functions that the converted\n function may call.\n experimental_optional_features: `None`, a tuple of, or a single\n `tf.autograph.experimental.Feature` value.\n\n Returns:\n Same as `entity`, the converted Python function or class.\n\n Raises:\n ValueError: If the entity could not be converted.\n ", "desc": "Converts a Python entity into a TensorFlow graph.", "type": "API"}, {"name": "tf.autograph.trace", "docs": "Traces argument information at compilation time.\n\n `trace` is useful when debugging, and it always executes during the tracing\n phase, that is, when the TF graph is constructed.\n\n _Example usage_\n\n ```python\n import tensorflow as tf\n\n for i in tf.range(10):\n tf.autograph.trace(i)\n # Output: \n ```\n\n Args:\n *args: Arguments to print to `sys.stdout`.\n ", "desc": "Traces argument information at compilation time.", "type": "API"}, {"name": "tf.batch_to_space", "docs": "BatchToSpace for N-D tensors of type T.\n\n This operation reshapes the \"batch\" dimension 0 into `M + 1` dimensions of\n shape `block_shape + [batch]`, interleaves these blocks back into the grid\n defined by the spatial dimensions `[1, ..., M]`, to obtain a result with the\n same rank as the input. The spatial dimensions of this intermediate result\n are then optionally cropped according to `crops` to produce the output. This\n is the reverse of SpaceToBatch (see `tf.space_to_batch`).\n\n Args:\n input: A N-D `Tensor` with shape `input_shape = [batch] + spatial_shape +\n remaining_shape`, where `spatial_shape` has M dimensions.\n block_shape: A 1-D `Tensor` with shape [M]. Must be one of the following\n types: `int32`, `int64`. All values must be >= 1. For backwards\n compatibility with TF 1.0, this parameter may be an int, in which case it\n is converted to\n `numpy.array([block_shape, block_shape],\n dtype=numpy.int64)`.\n crops: A 2-D `Tensor` with shape `[M, 2]`. Must be one of the\n following types: `int32`, `int64`. All values must be >= 0.\n `crops[i] = [crop_start, crop_end]` specifies the amount to crop from\n input dimension `i + 1`, which corresponds to spatial dimension `i`.\n It is required that\n `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.\n This operation is equivalent to the following steps:\n 1. Reshape `input` to `reshaped` of shape: [block_shape[0], ...,\n block_shape[M-1], batch / prod(block_shape), input_shape[1], ...,\n input_shape[N-1]]\n 2. Permute dimensions of `reshaped` to produce `permuted` of shape\n [batch / prod(block_shape), input_shape[1], block_shape[0], ...,\n input_shape[M], block_shape[M-1], input_shape[M+1],\n ..., input_shape[N-1]]\n 3. Reshape `permuted` to produce `reshaped_permuted` of shape\n [batch / prod(block_shape), input_shape[1] * block_shape[0], ...,\n input_shape[M] * block_shape[M-1], input_shape[M+1], ...,\n input_shape[N-1]]\n 4. Crop the start and end of dimensions `[1, ..., M]` of\n `reshaped_permuted` according to `crops` to produce the output\n of shape:\n [batch / prod(block_shape), input_shape[1] *\n block_shape[0] - crops[0,0] - crops[0,1], ..., input_shape[M] *\n block_shape[M-1] - crops[M-1,0] - crops[M-1,1], input_shape[M+1],\n ..., input_shape[N-1]]\n name: A name for the operation (optional).\n\n Examples:\n\n 1. For the following input of shape `[4, 1, 1, 1]`,\n `block_shape = [2, 2]`, and `crops = [[0, 0], [0, 0]]`:\n\n ```python\n [[[[1]]],\n [[[2]]],\n [[[3]]],\n [[[4]]]]\n ```\n\n The output tensor has shape `[1, 2, 2, 1]` and value:\n\n ```\n x = [[[[1], [2]],\n [[3], [4]]]]\n ```\n\n 2. For the following input of shape `[4, 1, 1, 3]`,\n `block_shape = [2, 2]`, and `crops = [[0, 0], [0, 0]]`:\n\n ```python\n [[[1, 2, 3]],\n [[4, 5, 6]],\n [[7, 8, 9]],\n [[10, 11, 12]]]\n ```\n\n The output tensor has shape `[1, 2, 2, 3]` and value:\n\n ```python\n x = [[[[1, 2, 3], [4, 5, 6 ]],\n [[7, 8, 9], [10, 11, 12]]]]\n ```\n\n 3. For the following\n input of shape `[4, 2, 2, 1]`,\n `block_shape = [2, 2]`, and `crops = [[0, 0], [0, 0]]`:\n\n ```python\n x = [[[[1], [3]], [[ 9], [11]]],\n [[[2], [4]], [[10], [12]]],\n [[[5], [7]], [[13], [15]]],\n [[[6], [8]], [[14], [16]]]]\n ```\n\n The output tensor has shape `[1, 4, 4, 1]` and value:\n\n ```python\n x = [[[1], [2], [ 3], [ 4]],\n [[5], [6], [ 7], [ 8]],\n [[9], [10], [11], [12]],\n [[13], [14], [15], [16]]]\n ```\n\n 4. For the following input of shape\n `[8, 1, 3, 1]`,\n `block_shape = [2, 2]`, and `crops = [[0, 0], [2, 0]]`:\n\n ```python\n x = [[[[0], [ 1], [ 3]]],\n [[[0], [ 9], [11]]],\n [[[0], [ 2], [ 4]]],\n [[[0], [10], [12]]],\n [[[0], [ 5], [ 7]]],\n [[[0], [13], [15]]],\n [[[0], [ 6], [ 8]]],\n [[[0], [14], [16]]]]\n ```\n\n The output tensor has shape `[2, 2, 4, 1]` and value:\n\n ```python\n x = [[[[ 1], [ 2], [ 3], [ 4]],\n [[ 5], [ 6], [ 7], [ 8]]],\n [[[ 9], [10], [11], [12]],\n [[13], [14], [15], [16]]]]\n ```\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "BatchToSpace for N-D tensors of type T.", "type": "API"}, {"name": "tf.bitcast", "docs": "Bitcasts a tensor from one type to another without copying data.\n\n Given a tensor `input`, this operation returns a tensor that has the same buffer\n data as `input` with datatype `type`.\n\n If the input datatype `T` is larger than the output datatype `type` then the\n shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].\n\n If `T` is smaller than `type`, the operator requires that the rightmost\n dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from\n [..., sizeof(`type`)/sizeof(`T`)] to [...].\n\n tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype\n (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast()\n gives module error.\n For example,\n\n Example 1:\n\n >>> a = [1., 2., 3.]\n >>> equality_bitcast = tf.bitcast(a, tf.complex128)\n Traceback (most recent call last):\n ...\n InvalidArgumentError: Cannot bitcast from 1 to 18 [Op:Bitcast]\n >>> equality_cast = tf.cast(a, tf.complex128)\n >>> print(equality_cast)\n tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128)\n\n Example 2:\n\n >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)\n \n\n Example 3:\n\n >>> x = [1., 2., 3.]\n >>> y = [0., 2., 3.]\n >>> equality= tf.equal(x,y)\n >>> equality_cast = tf.cast(equality,tf.float32)\n >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8)\n >>> print(equality)\n tf.Tensor([False True True], shape=(3,), dtype=bool)\n >>> print(equality_cast)\n tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32)\n >>> print(equality_bitcast)\n tf.Tensor(\n [[ 0 0 0 0]\n [ 0 0 128 63]\n [ 0 0 128 63]], shape=(3, 4), dtype=uint8)\n\n *NOTE*: Bitcast is implemented as a low-level cast, so machines with different\n endian orderings will give different results.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `complex64`, `complex128`, `qint8`, `quint8`, `qint16`, `quint16`, `qint32`.\n type: A `tf.DType` from: `tf.bfloat16, tf.half, tf.float32, tf.float64, tf.int64, tf.int32, tf.uint8, tf.uint16, tf.uint32, tf.uint64, tf.int8, tf.int16, tf.complex64, tf.complex128, tf.qint8, tf.quint8, tf.qint16, tf.quint16, tf.qint32`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `type`.\n ", "desc": "Bitcasts a tensor from one type to another without copying data.", "type": "API"}, {"name": "tf.bitwise", "docs": "Operations for manipulating the binary representations of integers.\n", "desc": "Operations for manipulating the binary representations of integers.", "type": "API"}, {"name": "tf.bitwise.bitwise_and", "docs": "Elementwise computes the bitwise AND of `x` and `y`.\n\n The result will have those bits set, that are set in both `x` and `y`. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_and(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise AND of `x` and `y`.", "type": "API"}, {"name": "tf.bitwise.bitwise_or", "docs": "Elementwise computes the bitwise OR of `x` and `y`.\n\n The result will have those bits set, that are set in `x`, `y` or both. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_or(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise OR of `x` and `y`.", "type": "API"}, {"name": "tf.bitwise.bitwise_xor", "docs": "Elementwise computes the bitwise XOR of `x` and `y`.\n\n The result will have those bits set, that are different in `x` and `y`. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([5, 5, 4, 5], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_xor(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise XOR of `x` and `y`.", "type": "API"}, {"name": "tf.bitwise.invert", "docs": "Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.\n\n Flip each bit of supported types. For example, type `int8` (decimal 2) binary 00000010 becomes (decimal -3) binary 11111101.\n This operation is performed on each element of the tensor argument `x`.\n\n Example:\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n\n # flip 2 (00000010) to -3 (11111101)\n tf.assert_equal(-3, bitwise_ops.invert(2))\n\n dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64,\n dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]\n\n inputs = [0, 5, 3, 14]\n for dtype in dtype_list:\n # Because of issues with negative numbers, let's test this indirectly.\n # 1. invert(a) and a = 0\n # 2. invert(a) or a = invert(0)\n input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype)\n not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and(\n input_tensor, bitwise_ops.invert(input_tensor)),\n bitwise_ops.bitwise_or(\n input_tensor, bitwise_ops.invert(input_tensor)),\n bitwise_ops.invert(\n tf.constant(0, dtype=dtype))]\n\n expected = tf.constant([0, 0, 0, 0], dtype=tf.float32)\n tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)\n\n expected = tf.cast([not_0] * 4, tf.float32)\n tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)\n\n # For unsigned dtypes let's also check the result directly.\n if dtype.is_unsigned:\n inverted = bitwise_ops.invert(input_tensor)\n expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32)\n tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.", "type": "API"}, {"name": "tf.bitwise.left_shift", "docs": "Elementwise computes the bitwise left-shift of `x` and `y`.\n\n If `y` is negative, or greater than or equal to the width of `x` in bits the\n result is implementation defined.\n\n Example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n import numpy as np\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]\n\n for dtype in dtype_list:\n lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n\n left_shift_result = bitwise_ops.left_shift(lhs, rhs)\n\n print(left_shift_result)\n\n # This will print:\n # tf.Tensor([ -32 -5 -128 0], shape=(4,), dtype=int8)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int16)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int32)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int64)\n\n lhs = np.array([-2, 64, 101, 32], dtype=np.int8)\n rhs = np.array([-1, -5, -3, -14], dtype=np.int8)\n bitwise_ops.left_shift(lhs, rhs)\n # \n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise left-shift of `x` and `y`.", "type": "API"}, {"name": "tf.bitwise.right_shift", "docs": "Elementwise computes the bitwise right-shift of `x` and `y`.\n\n Performs a logical shift for unsigned integer types, and an arithmetic shift\n for signed integer types.\n\n If `y` is negative, or greater than or equal to than the width of `x` in bits\n the result is implementation defined.\n\n Example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n import numpy as np\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]\n\n for dtype in dtype_list:\n lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n\n right_shift_result = bitwise_ops.right_shift(lhs, rhs)\n\n print(right_shift_result)\n\n # This will print:\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)\n\n lhs = np.array([-2, 64, 101, 32], dtype=np.int8)\n rhs = np.array([-1, -5, -3, -14], dtype=np.int8)\n bitwise_ops.right_shift(lhs, rhs)\n # \n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise right-shift of `x` and `y`.", "type": "API"}, {"name": "tf.boolean_mask", "docs": "Apply boolean mask to tensor.\n\n Numpy equivalent is `tensor[mask]`.\n\n In general, `0 < dim(mask) = K <= dim(tensor)`, and `mask`'s shape must match\n the first K dimensions of `tensor`'s shape. We then have:\n `boolean_mask(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd]`\n where `(i1,...,iK)` is the ith `True` entry of `mask` (row-major order).\n The `axis` could be used with `mask` to indicate the axis to mask from.\n In that case, `axis + dim(mask) <= dim(tensor)` and `mask`'s shape must match\n the first `axis + dim(mask)` dimensions of `tensor`'s shape.\n\n See also: `tf.ragged.boolean_mask`, which can be applied to both dense and\n ragged tensors, and can be used if you need to preserve the masked dimensions\n of `tensor` (rather than flattening them, as `tf.boolean_mask` does).\n\n Examples:\n\n >>> tensor = [0, 1, 2, 3] # 1-D example\n >>> mask = np.array([True, False, True, False])\n >>> tf.boolean_mask(tensor, mask)\n \n\n >>> tensor = [[1, 2], [3, 4], [5, 6]] # 2-D example\n >>> mask = np.array([True, False, True])\n >>> tf.boolean_mask(tensor, mask)\n \n\n Args:\n tensor: N-D Tensor.\n mask: K-D boolean Tensor, K <= N and K must be known statically.\n axis: A 0-D int Tensor representing the axis in `tensor` to mask from. By\n default, axis is 0 which will mask from the first dimension. Otherwise K +\n axis <= N.\n name: A name for this operation (optional).\n\n Returns:\n (N-K+1)-dimensional tensor populated by entries in `tensor` corresponding\n to `True` values in `mask`.\n\n Raises:\n ValueError: If shapes do not conform.\n\n Examples:\n\n ```python\n # 2-D example\n tensor = [[1, 2], [3, 4], [5, 6]]\n mask = np.array([True, False, True])\n boolean_mask(tensor, mask) # [[1, 2], [5, 6]]\n ```\n ", "desc": "Apply boolean mask to tensor.", "type": "API"}, {"name": "tf.broadcast_dynamic_shape", "docs": "Computes the shape of a broadcast given symbolic shapes.\n\n When `shape_x` and `shape_y` are Tensors representing shapes (i.e. the result\n of calling tf.shape on another Tensor) this computes a Tensor which is the\n shape of the result of a broadcasting op applied in tensors of shapes\n `shape_x` and `shape_y`.\n\n This is useful when validating the result of a broadcasting operation when the\n tensors do not have statically known shapes.\n\n Example:\n\n >>> shape_x = (1, 2, 3)\n >>> shape_y = (5, 1, 3)\n >>> tf.broadcast_dynamic_shape(shape_x, shape_y)\n \n\n Args:\n shape_x: A rank 1 integer `Tensor`, representing the shape of x.\n shape_y: A rank 1 integer `Tensor`, representing the shape of y.\n\n Returns:\n A rank 1 integer `Tensor` representing the broadcasted shape.\n\n Raises:\n InvalidArgumentError: If the two shapes are incompatible for\n broadcasting.\n ", "desc": "Computes the shape of a broadcast given symbolic shapes.", "type": "API"}, {"name": "tf.broadcast_static_shape", "docs": "Computes the shape of a broadcast given known shapes.\n\n When `shape_x` and `shape_y` are fully known `TensorShape`s this computes a\n `TensorShape` which is the shape of the result of a broadcasting op applied in\n tensors of shapes `shape_x` and `shape_y`.\n\n For example, if shape_x is `TensorShape([1, 2, 3])` and shape_y is\n `TensorShape([5, 1, 3])`, the result is a TensorShape whose value is\n `TensorShape([5, 2, 3])`.\n\n This is useful when validating the result of a broadcasting operation when the\n tensors have statically known shapes.\n\n Example:\n\n >>> shape_x = tf.TensorShape([1, 2, 3])\n >>> shape_y = tf.TensorShape([5, 1 ,3])\n >>> tf.broadcast_static_shape(shape_x, shape_y)\n TensorShape([5, 2, 3])\n\n Args:\n shape_x: A `TensorShape`\n shape_y: A `TensorShape`\n\n Returns:\n A `TensorShape` representing the broadcasted shape.\n\n Raises:\n ValueError: If the two shapes can not be broadcasted.\n ", "desc": "Computes the shape of a broadcast given known shapes.", "type": "API"}, {"name": "tf.broadcast_to", "docs": "Broadcast an array for a compatible shape.\n\n Broadcasting is the process of making arrays to have compatible shapes\n for arithmetic operations. Two shapes are compatible if for each\n dimension pair they are either equal or one of them is one. When trying\n to broadcast a Tensor to a shape, it starts with the trailing dimensions,\n and works its way forward.\n\n For example,\n\n >>> x = tf.constant([1, 2, 3])\n >>> y = tf.broadcast_to(x, [3, 3])\n >>> print(y)\n tf.Tensor(\n [[1 2 3]\n [1 2 3]\n [1 2 3]], shape=(3, 3), dtype=int32)\n\n In the above example, the input Tensor with the shape of `[1, 3]`\n is broadcasted to output Tensor with shape of `[3, 3]`.\n\n When doing broadcasted operations such as multiplying a tensor\n by a scalar, broadcasting (usually) confers some time or space\n benefit, as the broadcasted tensor is never materialized.\n\n However, `broadcast_to` does not carry with it any such benefits.\n The newly-created tensor takes the full memory of the broadcasted\n shape. (In a graph context, `broadcast_to` might be fused to\n subsequent operation and then be optimized away, however.)\n\n Args:\n input: A `Tensor`. A Tensor to broadcast.\n shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n An 1-D `int` Tensor. The shape of the desired output.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "Broadcast an array for a compatible shape.", "type": "API"}, {"name": "tf.case", "docs": "Create a case operation.\n\n See also `tf.switch_case`.\n\n The `pred_fn_pairs` parameter is a list of pairs of size N.\n Each pair contains a boolean scalar tensor and a python callable that\n creates the tensors to be returned if the boolean evaluates to True.\n `default` is a callable generating a list of tensors. All the callables\n in `pred_fn_pairs` as well as `default` (if provided) should return the same\n number and types of tensors.\n\n If `exclusive==True`, all predicates are evaluated, and an exception is\n thrown if more than one of the predicates evaluates to `True`.\n If `exclusive==False`, execution stops at the first predicate which\n evaluates to True, and the tensors generated by the corresponding function\n are returned immediately. If none of the predicates evaluate to True, this\n operation returns the tensors generated by `default`.\n\n `tf.case` supports nested structures as implemented in\n `tf.nest`. All of the callables must return the same (possibly nested) value\n structure of lists, tuples, and/or named tuples. Singleton lists and tuples\n form the only exceptions to this: when returned by a callable, they are\n implicitly unpacked to single values. This behavior is disabled by passing\n `strict=True`.\n\n @compatibility(v2)\n `pred_fn_pairs` could be a dictionary in v1. However, tf.Tensor and\n tf.Variable are no longer hashable in v2, so cannot be used as a key for a\n dictionary. Please use a list or a tuple instead.\n @end_compatibility\n\n\n **Example 1:**\n\n Pseudocode:\n\n ```\n if (x < y) return 17;\n else return 23;\n ```\n\n Expressions:\n\n ```python\n f1 = lambda: tf.constant(17)\n f2 = lambda: tf.constant(23)\n r = tf.case([(tf.less(x, y), f1)], default=f2)\n ```\n\n **Example 2:**\n\n Pseudocode:\n\n ```\n if (x < y && x > z) raise OpError(\"Only one predicate may evaluate to True\");\n if (x < y) return 17;\n else if (x > z) return 23;\n else return -1;\n ```\n\n Expressions:\n\n ```python\n def f1(): return tf.constant(17)\n def f2(): return tf.constant(23)\n def f3(): return tf.constant(-1)\n r = tf.case([(tf.less(x, y), f1), (tf.greater(x, z), f2)],\n default=f3, exclusive=True)\n ```\n\n Args:\n pred_fn_pairs: List of pairs of a boolean scalar tensor and a callable which\n returns a list of tensors.\n default: Optional callable that returns a list of tensors.\n exclusive: True iff at most one predicate is allowed to evaluate to `True`.\n strict: A boolean that enables/disables 'strict' mode; see above.\n name: A name for this operation (optional).\n\n Returns:\n The tensors returned by the first pair whose predicate evaluated to True, or\n those returned by `default` if none does.\n\n Raises:\n TypeError: If `pred_fn_pairs` is not a list/tuple.\n TypeError: If `pred_fn_pairs` is a list but does not contain 2-tuples.\n TypeError: If `fns[i]` is not callable for any i, or `default` is not\n callable.\n ", "desc": "Create a case operation.", "type": "API"}, {"name": "tf.cast", "docs": "Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.cast(x, tf.int32)\n \n\n Notice `tf.cast` has an alias `tf.dtypes.cast`:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.dtypes.cast(x, tf.int32)\n \n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Note casting nan and inf values to integral types has undefined behavior.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n ", "desc": "Casts a tensor to a new type.", "type": "API"}, {"name": "tf.clip_by_global_norm", "docs": "Clips values of multiple tensors by the ratio of the sum of their norms.\n\n Given a tuple or list of tensors `t_list`, and a clipping ratio `clip_norm`,\n this operation returns a list of clipped tensors `list_clipped`\n and the global norm (`global_norm`) of all tensors in `t_list`. Optionally,\n if you've already computed the global norm for `t_list`, you can specify\n the global norm with `use_norm`.\n\n To perform the clipping, the values `t_list[i]` are set to:\n\n t_list[i] * clip_norm / max(global_norm, clip_norm)\n\n where:\n\n global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))\n\n If `clip_norm > global_norm` then the entries in `t_list` remain as they are,\n otherwise they're all shrunk by the global ratio.\n\n If `global_norm == infinity` then the entries in `t_list` are all set to `NaN`\n to signal that an error occurred.\n\n Any of the entries of `t_list` that are of type `None` are ignored.\n\n This is the correct way to perform gradient clipping (Pascanu et al., 2012).\n\n However, it is slower than `clip_by_norm()` because all the parameters must be\n ready before the clipping operation can be performed.\n\n Args:\n t_list: A tuple or list of mixed `Tensors`, `IndexedSlices`, or None.\n clip_norm: A 0-D (scalar) `Tensor` > 0. The clipping ratio.\n use_norm: A 0-D (scalar) `Tensor` of type `float` (optional). The global\n norm to use. If not provided, `global_norm()` is used to compute the norm.\n name: A name for the operation (optional).\n\n Returns:\n list_clipped: A list of `Tensors` of the same type as `list_t`.\n global_norm: A 0-D (scalar) `Tensor` representing the global norm.\n\n Raises:\n TypeError: If `t_list` is not a sequence.\n\n References:\n On the difficulty of training Recurrent Neural Networks:\n [Pascanu et al., 2012](http://proceedings.mlr.press/v28/pascanu13.html)\n ([pdf](http://proceedings.mlr.press/v28/pascanu13.pdf))\n ", "desc": "Clips values of multiple tensors by the ratio of the sum of their norms.", "type": "API"}, {"name": "tf.clip_by_norm", "docs": "Clips tensor values to a maximum L2-norm.\n\n Given a tensor `t`, and a maximum clip value `clip_norm`, this operation\n normalizes `t` so that its L2-norm is less than or equal to `clip_norm`,\n along the dimensions given in `axes`. Specifically, in the default case\n where all dimensions are used for calculation, if the L2-norm of `t` is\n already less than or equal to `clip_norm`, then `t` is not modified. If\n the L2-norm is greater than `clip_norm`, then this operation returns a\n tensor of the same type and shape as `t` with its values set to:\n\n `t * clip_norm / l2norm(t)`\n\n In this case, the L2-norm of the output tensor is `clip_norm`.\n\n As another example, if `t` is a matrix and `axes == [1]`, then each row\n of the output will have L2-norm less than or equal to `clip_norm`. If\n `axes == [0]` instead, each column of the output will be clipped.\n\n Code example:\n\n >>> some_nums = tf.constant([[1, 2, 3, 4, 5]], dtype=tf.float32)\n >>> tf.clip_by_norm(some_nums, 2.0).numpy()\n array([[0.26967996, 0.5393599 , 0.80903983, 1.0787199 , 1.3483998 ]],\n dtype=float32)\n\n This operation is typically used to clip gradients before applying them with\n an optimizer. Most gradient data is a collection of different shaped tensors\n for different parts of the model. Thus, this is a common usage:\n\n ```\n # Get your gradients after training\n loss_value, grads = grad(model, features, labels)\n\n # Apply some clipping\n grads = [tf.clip_by_norm(g, norm)\n for g in grads]\n\n # Continue on with training\n optimizer.apply_gradients(grads)\n ```\n\n Args:\n t: A `Tensor` or `IndexedSlices`. This must be a floating point type.\n clip_norm: A 0-D (scalar) `Tensor` > 0. A maximum clipping value, also\n floating point\n axes: A 1-D (vector) `Tensor` of type int32 containing the dimensions\n to use for computing the L2-norm. If `None` (the default), uses all\n dimensions.\n name: A name for the operation (optional).\n\n Returns:\n A clipped `Tensor` or `IndexedSlices`.\n\n Raises:\n ValueError: If the clip_norm tensor is not a 0-D scalar tensor.\n TypeError: If dtype of the input is not a floating point or\n complex type.\n ", "desc": "Clips tensor values to a maximum L2-norm.", "type": "API"}, {"name": "tf.clip_by_value", "docs": "Clips tensor values to a specified min and max.\n\n Given a tensor `t`, this operation returns a tensor of the same type and\n shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`.\n Any values less than `clip_value_min` are set to `clip_value_min`. Any values\n greater than `clip_value_max` are set to `clip_value_max`.\n\n Note: `clip_value_min` needs to be smaller or equal to `clip_value_max` for\n correct results.\n\n For example:\n\n Basic usage passes a scalar as the min and max value.\n\n >>> t = tf.constant([[-10., -1., 0.], [0., 2., 10.]])\n >>> t2 = tf.clip_by_value(t, clip_value_min=-1, clip_value_max=1)\n >>> t2.numpy()\n array([[-1., -1., 0.],\n [ 0., 1., 1.]], dtype=float32)\n\n The min and max can be the same size as `t`, or broadcastable to that size.\n\n >>> t = tf.constant([[-1, 0., 10.], [-1, 0, 10]])\n >>> clip_min = [[2],[1]]\n >>> t3 = tf.clip_by_value(t, clip_value_min=clip_min, clip_value_max=100)\n >>> t3.numpy()\n array([[ 2., 2., 10.],\n [ 1., 1., 10.]], dtype=float32)\n\n Broadcasting fails, intentionally, if you would expand the dimensions of `t`\n\n >>> t = tf.constant([[-1, 0., 10.], [-1, 0, 10]])\n >>> clip_min = [[[2, 1]]] # Has a third axis\n >>> t4 = tf.clip_by_value(t, clip_value_min=clip_min, clip_value_max=100)\n Traceback (most recent call last):\n ...\n InvalidArgumentError: Incompatible shapes: [2,3] vs. [1,1,2]\n\n It throws a `TypeError` if you try to clip an `int` to a `float` value\n (`tf.cast` the input to `float` first).\n\n >>> t = tf.constant([[1, 2], [3, 4]], dtype=tf.int32)\n >>> t5 = tf.clip_by_value(t, clip_value_min=-3.1, clip_value_max=3.1)\n Traceback (most recent call last):\n ...\n TypeError: Cannot convert ...\n\n\n Args:\n t: A `Tensor` or `IndexedSlices`.\n clip_value_min: The minimum value to clip to. A scalar `Tensor` or one that\n is broadcastable to the shape of `t`.\n clip_value_max: The maximum value to clip to. A scalar `Tensor` or one that\n is broadcastable to the shape of `t`.\n name: A name for the operation (optional).\n\n Returns:\n A clipped `Tensor` or `IndexedSlices`.\n\n Raises:\n `tf.errors.InvalidArgumentError`: If the clip tensors would trigger array\n broadcasting that would make the returned tensor larger than the input.\n TypeError: If dtype of the input is `int32` and dtype of\n the `clip_value_min` or `clip_value_max` is `float32`\n ", "desc": "Clips tensor values to a specified min and max.", "type": "API"}, {"name": "tf.compat", "docs": "Compatibility functions.\n\nThe `tf.compat` module contains two sets of compatibility functions.\n\n## Tensorflow 1.x and 2.x APIs\n\nThe `compat.v1` and `compat.v2` submodules provide a complete copy of both the\n`v1` and `v2` APIs for backwards and forwards compatibility across TensorFlow\nversions 1.x and 2.x. See the\n[migration guide](https://www.tensorflow.org/guide/migrate) for details.\n\n## Utilities for writing compatible code\n\nAside from the `compat.v1` and `compat.v2` submodules, `tf.compat` also contains\na set of helper functions for writing code that works in both:\n\n* TensorFlow 1.x and 2.x\n* Python 2 and 3\n\n\n## Type collections\n\nThe compatibility module also provides the following aliases for common\nsets of python types:\n\n* `bytes_or_text_types`\n* `complex_types`\n* `integral_types`\n* `real_types`\n\n", "desc": "Compatibility functions.", "type": "API"}, {"name": "tf.compat.as_bytes", "docs": "Converts `bytearray`, `bytes`, or unicode python input types to `bytes`.\n\n Uses utf-8 encoding for text by default.\n\n Args:\n bytes_or_text: A `bytearray`, `bytes`, `str`, or `unicode` object.\n encoding: A string indicating the charset for encoding unicode.\n\n Returns:\n A `bytes` object.\n\n Raises:\n TypeError: If `bytes_or_text` is not a binary or unicode string.\n ", "desc": "Converts `bytearray`, `bytes`, or unicode python input types to `bytes`.", "type": "API"}, {"name": "tf.compat.as_str", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.as_str_any", "docs": "Converts input to `str` type.\n\n Uses `str(value)`, except for `bytes` typed inputs, which are converted\n using `as_str`.\n\n Args:\n value: A object that can be converted to `str`.\n\n Returns:\n A `str` object.\n ", "desc": "Converts input to `str` type.", "type": "API"}, {"name": "tf.compat.as_text", "docs": "Converts any string-like python input types to unicode.\n\n Returns the input as a unicode string. Uses utf-8 encoding for text\n by default.\n\n Args:\n bytes_or_text: A `bytes`, `str`, or `unicode` object.\n encoding: A string indicating the charset for decoding unicode.\n\n Returns:\n A `unicode` (Python 2) or `str` (Python 3) object.\n\n Raises:\n TypeError: If `bytes_or_text` is not a binary or unicode string.\n ", "desc": "Converts any string-like python input types to unicode.", "type": "API"}, {"name": "tf.compat.dimension_at_index", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n If you want to retrieve the Dimension instance corresponding to a certain\n index in a TensorShape instance, use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n dim = tensor_shape[i]\n\n # Use `dimension_at_index` as direct replacement compatible with both V1 & V2:\n dim = dimension_at_index(tensor_shape, i)\n\n # Another possibility would be this, but WARNING: it only works if the\n # tensor_shape instance has a defined rank.\n dim = tensor_shape.dims[i] # `dims` may be None if the rank is undefined!\n\n # In native V2 code, we recommend instead being more explicit:\n if tensor_shape.rank is None:\n dim = Dimension(None)\n else:\n dim = tensor_shape.dims[i]\n\n # Being more explicit will save you from the following trap (present in V1):\n # you might do in-place modifications to `dim` and expect them to be reflected\n # in `tensor_shape[i]`, but they would not be (as the Dimension object was\n # instantiated on the fly.\n ```\n\n Args:\n shape: A TensorShape instance.\n index: An integer index.\n\n Returns:\n A dimension object.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.dimension_value", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n When accessing the value of a TensorShape dimension,\n use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n value = tensor_shape[i].value\n\n # Use `dimension_value` as direct replacement compatible with both V1 & V2:\n value = dimension_value(tensor_shape[i])\n\n # This would be the V2 equivalent:\n value = tensor_shape[i] # Warning: this will return the dim value in V2!\n ```\n\n Args:\n dimension: Either a `Dimension` instance, an integer, or None.\n\n Returns:\n A plain value, i.e. an integer or None.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.forward_compatibility_horizon", "docs": "Context manager for testing forward compatibility of generated graphs.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n To ensure forward compatibility of generated graphs (see `forward_compatible`)\n with older binaries, new features can be gated with:\n\n ```python\n if compat.forward_compatible(year=2018, month=08, date=01):\n generate_graph_with_new_features()\n else:\n generate_graph_so_older_binaries_can_consume_it()\n ```\n\n However, when adding new features, one may want to unittest it before\n the forward compatibility window expires. This context manager enables\n such tests. For example:\n\n ```python\n from tensorflow.python.compat import compat\n\n def testMyNewFeature(self):\n with compat.forward_compatibility_horizon(2018, 08, 02):\n # Test that generate_graph_with_new_features() has an effect\n ```\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Yields:\n Nothing.\n ", "desc": "Context manager for testing forward compatibility of generated graphs.", "type": "API"}, {"name": "tf.compat.forward_compatible", "docs": "Return true if the forward compatibility window has expired.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n Forward-compatibility refers to scenarios where the producer of a TensorFlow\n model (a GraphDef or SavedModel) is compiled against a version of the\n TensorFlow library newer than what the consumer was compiled against. The\n \"producer\" is typically a Python program that constructs and trains a model\n while the \"consumer\" is typically another program that loads and serves the\n model.\n\n TensorFlow has been supporting a 3 week forward-compatibility window for\n programs compiled from source at HEAD.\n\n For example, consider the case where a new operation `MyNewAwesomeAdd` is\n created with the intent of replacing the implementation of an existing Python\n wrapper - `tf.add`. The Python wrapper implementation should change from\n something like:\n\n ```python\n def add(inputs, name=None):\n return gen_math_ops.add(inputs, name)\n ```\n\n to:\n\n ```python\n from tensorflow.python.compat import compat\n\n def add(inputs, name=None):\n if compat.forward_compatible(year, month, day):\n # Can use the awesome new implementation.\n return gen_math_ops.my_new_awesome_add(inputs, name)\n # To maintain forward compatibility, use the old implementation.\n return gen_math_ops.add(inputs, name)\n ```\n\n Where `year`, `month`, and `day` specify the date beyond which binaries\n that consume a model are expected to have been updated to include the\n new operations. This date is typically at least 3 weeks beyond the date\n the code that adds the new operation is committed.\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Returns:\n True if the caller can expect that serialized TensorFlow graphs produced\n can be consumed by programs that are compiled with the TensorFlow library\n source code after (year, month, day).\n ", "desc": "Return true if the forward compatibility window has expired.", "type": "API"}, {"name": "tf.compat.path_to_str", "docs": "Converts input which is a `PathLike` object to `str` type.\n\n Converts from any python constant representation of a `PathLike` object to\n a string. If the input is not a `PathLike` object, simply returns the input.\n\n Args:\n path: An object that can be converted to path representation.\n\n Returns:\n A `str` object.\n\n Usage:\n In case a simplified `str` version of the path is needed from an\n `os.PathLike` object\n\n Examples:\n ```python\n $ tf.compat.path_to_str('C:\\XYZ\\tensorflow\\./.././tensorflow')\n 'C:\\XYZ\\tensorflow\\./.././tensorflow' # Windows OS\n $ tf.compat.path_to_str(Path('C:\\XYZ\\tensorflow\\./.././tensorflow'))\n 'C:\\XYZ\\tensorflow\\..\\tensorflow' # Windows OS\n $ tf.compat.path_to_str(Path('./corpus'))\n 'corpus' # Linux OS\n $ tf.compat.path_to_str('./.././Corpus')\n './.././Corpus' # Linux OS\n $ tf.compat.path_to_str(Path('./.././Corpus'))\n '../Corpus' # Linux OS\n $ tf.compat.path_to_str(Path('./..////../'))\n '../..' # Linux OS\n\n ```\n ", "desc": "Converts input which is a `PathLike` object to `str` type.", "type": "API"}, {"name": "tf.compat.v1", "docs": "Bring in all of the public TensorFlow interface into this module.", "desc": "Bring in all of the public TensorFlow interface into this module.", "type": "API"}, {"name": "tf.compat.v1.abs", "docs": "Computes the absolute value of a tensor.\n\n Given a tensor of integer or floating-point values, this operation returns a\n tensor of the same type, where each element contains the absolute value of the\n corresponding element in the input.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. For\n a complex number \\\\(a + bj\\\\), its absolute value is computed as\n \\\\(\\sqrt{a^2 + b^2}\\\\).\n\n For example:\n\n >>> # real number\n >>> x = tf.constant([-2.25, 3.25])\n >>> tf.abs(x)\n \n\n >>> # complex number\n >>> x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n >>> tf.abs(x)\n \n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` of the same size, type and sparsity as `x`,\n with absolute values. Note, for `complex64` or `complex128` input, the\n returned `Tensor` will be of type `float32` or `float64`, respectively.\n\n If `x` is a `SparseTensor`, returns\n `SparseTensor(x.indices, tf.math.abs(x.values, ...), x.dense_shape)`", "desc": "Computes the absolute value of a tensor.", "type": "API"}, {"name": "tf.compat.v1.accumulate_n", "docs": "Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `accumulate_n` performs the same operation as `tf.math.add_n`.\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Expected shape of elements of `inputs` (optional). Also controls the\n output shape of this op, which may affect type inference in other ops. A\n value of `None` means \"infer the input shape from the shapes in `inputs`\".\n tensor_dtype: Expected data type of `inputs` (optional). A value of `None`\n means \"infer the input dtype from `inputs[0]`\".\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n ", "desc": "Returns the element-wise sum of a list of tensors.", "type": "API"}, {"name": "tf.compat.v1.acos", "docs": "Computes acos of x element-wise.\n\n Provided an input tensor, the `tf.math.acos` operation\n returns the inverse cosine of each element of the tensor.\n If `y = tf.math.cos(x)` then, `x = tf.math.acos(y)`.\n\n Input range is `[-1, 1]` and the output has a range of `[0, pi]`.\n\n For example:\n\n >>> x = tf.constant([1.0, -0.5, 3.4, 0.2, 0.0, -2], dtype = tf.float32)\n >>> tf.math.acos(x)\n \n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`,\n `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as x.\n ", "desc": "Computes acos of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.acosh", "docs": "Computes inverse hyperbolic cosine of x element-wise.\n\n Given an input tensor, the function computes inverse hyperbolic cosine of every element.\n Input range is `[1, inf]`. It returns `nan` if the input lies outside the range.\n\n ```python\n x = tf.constant([-2, -0.5, 1, 1.2, 200, 10000, float(\"inf\")])\n tf.math.acosh(x) ==> [nan nan 0. 0.62236255 5.9914584 9.903487 inf]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic cosine of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.add", "docs": "Returns x + y element-wise.\n\n Example usages below.\n\n Add a scalar and a list:\n\n >>> x = [1, 2, 3, 4, 5]\n >>> y = 1\n >>> tf.add(x, y)\n \n\n Note that binary `+` operator can be used instead:\n\n >>> x = tf.convert_to_tensor([1, 2, 3, 4, 5])\n >>> y = tf.convert_to_tensor(1)\n >>> x + y\n \n\n Add a tensor and a list of same shape:\n\n >>> x = [1, 2, 3, 4, 5]\n >>> y = tf.constant([1, 2, 3, 4, 5])\n >>> tf.add(x, y)\n \n\n **Warning**: If one of the inputs (`x` or `y`) is a tensor and the other is a\n non-tensor, the non-tensor input will adopt (or get casted to) the data type\n of the tensor input. This can potentially cause unwanted overflow or underflow\n conversion.\n\n For example,\n\n >>> x = tf.constant([1, 2], dtype=tf.int8)\n >>> y = [2**7 + 1, 2**7 + 2]\n >>> tf.add(x, y)\n \n\n When adding two input values of different shapes, `Add` follows NumPy\n broadcasting rules. The two input array shapes are compared element-wise.\n Starting with the trailing dimensions, the two dimensions either have to be\n equal or one of them needs to be `1`.\n\n For example,\n\n >>> x = np.ones(6).reshape(1, 2, 1, 3)\n >>> y = np.ones(6).reshape(2, 1, 3, 1)\n >>> tf.add(x, y).shape.as_list()\n [2, 2, 3, 3]\n\n Another example with two arrays of different dimension.\n\n >>> x = np.ones([1, 2, 1, 4])\n >>> y = np.ones([3, 4])\n >>> tf.add(x, y).shape.as_list()\n [1, 2, 3, 4]\n\n The reduction version of this elementwise operation is `tf.math.reduce_sum`\n\n Args:\n x: A `tf.Tensor`. Must be one of the following types: bfloat16, half,\n float32, float64, uint8, int8, int16, int32, int64, complex64, complex128,\n string.\n y: A `tf.Tensor`. Must have the same type as x.\n name: A name for the operation (optional)\n ", "desc": "Returns x + y element-wise.", "type": "API"}, {"name": "tf.compat.v1.add_check_numerics_ops", "docs": "Connect a `tf.debugging.check_numerics` to every floating point tensor.\n\n `check_numerics` operations themselves are added for each `half`, `float`,\n or `double` tensor in the current default graph. For all ops in the graph, the\n `check_numerics` op for all of its (`half`, `float`, or `double`) inputs\n is guaranteed to run before the `check_numerics` op on any of its outputs.\n\n Note: This API is not compatible with the use of `tf.cond` or\n `tf.while_loop`, and will raise a `ValueError` if you attempt to call it\n in such a graph.\n\n Returns:\n A `group` op depending on all `check_numerics` ops added.\n\n Raises:\n ValueError: If the graph contains any numeric operations in a control flow\n structure.\n RuntimeError: If called with eager execution enabled.\n\n @compatibility(eager)\n Not compatible with eager execution. To check for `Inf`s and `NaN`s under\n eager execution, call `tf.debugging.enable_check_numerics()` once before\n executing the checked operations.\n @end_compatibility\n ", "desc": "Connect a `tf.debugging.check_numerics` to every floating point tensor.", "type": "API"}, {"name": "tf.compat.v1.add_n", "docs": "Adds all input tensors element-wise.\n\n `tf.math.add_n` performs the same operation as `tf.math.accumulate_n`.\n\n This op does not [broadcast](\n https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)\n its inputs. If you need broadcasting, use `tf.math.add` (or the `+` operator)\n instead.\n\n For example:\n\n >>> a = tf.constant([[3, 5], [4, 8]])\n >>> b = tf.constant([[1, 6], [2, 9]])\n >>> tf.math.add_n([a, b, a])\n \n\n Args:\n inputs: A list of `tf.Tensor` or `tf.IndexedSlices` objects, each with the\n same shape and type. `tf.IndexedSlices` objects will be converted into\n dense tensors prior to adding.\n name: A name for the operation (optional).\n\n Returns:\n A `tf.Tensor` of the same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n ", "desc": "Adds all input tensors element-wise.", "type": "API"}, {"name": "tf.compat.v1.add_to_collection", "docs": "Wrapper for `Graph.add_to_collection()` using the default graph.\n\n See `tf.Graph.add_to_collection`\n for more details.\n\n Args:\n name: The key for the collection. For example, the `GraphKeys` class\n contains many standard names for collections.\n value: The value to add to the collection.\n\n @compatibility(eager)\n Collections are only supported in eager when variables are created inside\n an EagerVariableStore (e.g. as part of a layer or template).\n @end_compatibility\n ", "desc": "Wrapper for `Graph.add_to_collection()` using the default graph.", "type": "API"}, {"name": "tf.compat.v1.add_to_collections", "docs": "Wrapper for `Graph.add_to_collections()` using the default graph.\n\n See `tf.Graph.add_to_collections`\n for more details.\n\n Args:\n names: The key for the collections. The `GraphKeys` class contains many\n standard names for collections.\n value: The value to add to the collections.\n\n @compatibility(eager)\n Collections are only supported in eager when variables are created inside\n an EagerVariableStore (e.g. as part of a layer or template).\n @end_compatibility\n ", "desc": "Wrapper for `Graph.add_to_collections()` using the default graph.", "type": "API"}, {"name": "tf.compat.v1.AggregationMethod", "docs": "A class listing aggregation methods used to combine gradients.\n\n Computing partial derivatives can require aggregating gradient\n contributions. This class lists the various methods that can\n be used to combine gradients in the graph.\n\n The following aggregation methods are part of the stable API for\n aggregating gradients:\n\n * `ADD_N`: All of the gradient terms are summed as part of one\n operation using the \"AddN\" op (see `tf.add_n`). This\n method has the property that all gradients must be ready and\n buffered separately in memory before any aggregation is performed.\n * `DEFAULT`: The system-chosen default aggregation method.\n\n The following aggregation methods are experimental and may not\n be supported in future releases:\n\n * `EXPERIMENTAL_TREE`: Gradient terms are summed in pairs using\n the \"AddN\" op. This method of summing gradients may reduce\n performance, but it can improve memory utilization because the\n gradients can be released earlier.\n\n ", "desc": "A class listing aggregation methods used to combine gradients.", "type": "API"}, {"name": "tf.compat.v1.all_variables", "docs": "Use `tf.compat.v1.global_variables` instead. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed after 2017-03-02.\nInstructions for updating:\nPlease use tf.global_variables instead.", "desc": "Use `tf.compat.v1.global_variables` instead. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.angle", "docs": "Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n input = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j], dtype=tf.complex64)\n tf.math.angle(input).numpy()\n # ==> array([2.0131705, 1.056345 ], dtype=float32)\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n ", "desc": "Returns the element-wise argument of a complex (or real) tensor.", "type": "API"}, {"name": "tf.compat.v1.app", "docs": "Generic entry point script.\n", "desc": "Generic entry point script.", "type": "API"}, {"name": "tf.compat.v1.app.flags", "docs": "Import router for absl.flags. See https://github.com/abseil/abseil-py.", "desc": "Import router for absl.flags. See https://github.com/abseil/abseil-py.", "type": "API"}, {"name": "tf.compat.v1.app.flags.adopt_module_key_flags", "docs": "Declares that all flags key to a module are key to the current module.\n\n Args:\n module: module, the module object from which all key flags will be declared\n as key flags to the current module.\n flag_values: FlagValues, the FlagValues instance in which the flags will be\n declared as key flags. This should almost never need to be overridden.\n\n Raises:\n Error: Raised when given an argument that is a module name (a string),\n instead of a module object.\n ", "desc": "Declares that all flags key to a module are key to the current module.", "type": "API"}, {"name": "tf.compat.v1.app.flags.ArgumentParser", "docs": "Base class used to parse and convert arguments.\n\n The parse() method checks to make sure that the string argument is a\n legal value and convert it to a native type. If the value cannot be\n converted, it should throw a 'ValueError' exception with a human\n readable explanation of why the value is illegal.\n\n Subclasses should also define a syntactic_help string which may be\n presented to the user to describe the form of the legal values.\n\n Argument parser classes must be stateless, since instances are cached\n and shared between flags. Initializer arguments are allowed, but all\n member variables must be derived from initializer arguments only.\n ", "desc": "Base class used to parse and convert arguments.", "type": "API"}, {"name": "tf.compat.v1.app.flags.ArgumentSerializer", "docs": "Base class for generating string representations of a flag value.", "desc": "Base class for generating string representations of a flag value.", "type": "API"}, {"name": "tf.compat.v1.app.flags.BaseListParser", "docs": "Base class for a parser of lists of strings.\n\n To extend, inherit from this class; from the subclass __init__, call\n\n BaseListParser.__init__(self, token, name)\n\n where token is a character used to tokenize, and name is a description\n of the separator.\n ", "desc": "Base class for a parser of lists of strings.", "type": "API"}, {"name": "tf.compat.v1.app.flags.BooleanFlag", "docs": "Basic boolean flag.\n\n Boolean flags do not take any arguments, and their value is either\n True (1) or False (0). The false value is specified on the command\n line by prepending the word 'no' to either the long or the short flag\n name.\n\n For example, if a Boolean flag was created whose long name was\n 'update' and whose short name was 'x', then this flag could be\n explicitly unset through either --noupdate or --nox.\n ", "desc": "Basic boolean flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.BooleanParser", "docs": "Parser of boolean values.", "desc": "Parser of boolean values.", "type": "API"}, {"name": "tf.compat.v1.app.flags.CantOpenFlagFileError", "docs": "Raised when flagfile fails to open.\n\n E.g. the file doesn't exist, or has wrong permissions.\n ", "desc": "Raised when flagfile fails to open.", "type": "API"}, {"name": "tf.compat.v1.app.flags.CsvListSerializer", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.app.flags.declare_key_flag", "docs": "Declares one flag as key to the current module.\n\n Key flags are flags that are deemed really important for a module.\n They are important when listing help messages; e.g., if the\n --helpshort command-line flag is used, then only the key flags of the\n main module are listed (instead of all flags, as in the case of\n --helpfull).\n\n Sample usage:\n\n flags.declare_key_flag('flag_1')\n\n Args:\n flag_name: str, the name of an already declared flag. (Redeclaring flags as\n key, including flags implicitly key because they were declared in this\n module, is a no-op.)\n flag_values: FlagValues, the FlagValues instance in which the flag will be\n declared as a key flag. This should almost never need to be overridden.\n\n Raises:\n ValueError: Raised if flag_name not defined as a Python flag.\n ", "desc": "Declares one flag as key to the current module.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE", "docs": "Registers a generic Flag object.\n\n NOTE: in the docstrings of all DEFINE* functions, \"registers\" is short\n for \"creates a new flag and registers it\".\n\n Auxiliary function: clients should use the specialized DEFINE_\n function instead.\n\n Args:\n parser: ArgumentParser, used to parse the flag arguments.\n name: str, the flag name.\n default: The default value of the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n serializer: ArgumentSerializer, the flag serializer instance.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to Flag __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a generic Flag object.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_alias", "docs": "Defines an alias flag for an existing one.\n\n Args:\n name: str, the flag name.\n original_name: str, the original flag name.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: A string, the name of the module that defines this flag.\n\n Returns:\n a handle to defined flag.\n\n Raises:\n flags.FlagError:\n UnrecognizedFlagError: if the referenced flag doesn't exist.\n DuplicateFlagError: if the alias name has been used by some existing flag.\n ", "desc": "Defines an alias flag for an existing one.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_bool", "docs": "Registers a boolean flag.\n\n Such a boolean flag does not take an argument. If a user wants to\n specify a false value explicitly, the long option beginning with 'no'\n must be used: i.e. --noflag\n\n This flag will have a value of None, True or False. None is possible\n if default=None and the user does not specify the flag on the command\n line.\n\n Args:\n name: str, the flag name.\n default: bool|str|None, the default value of the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to Flag __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a boolean flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_boolean", "docs": "Registers a boolean flag.\n\n Such a boolean flag does not take an argument. If a user wants to\n specify a false value explicitly, the long option beginning with 'no'\n must be used: i.e. --noflag\n\n This flag will have a value of None, True or False. None is possible\n if default=None and the user does not specify the flag on the command\n line.\n\n Args:\n name: str, the flag name.\n default: bool|str|None, the default value of the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to Flag __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a boolean flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_enum", "docs": "Registers a flag whose value can be any string from enum_values.\n\n Instead of a string enum, prefer `DEFINE_enum_class`, which allows\n defining enums from an `enum.Enum` class.\n\n Args:\n name: str, the flag name.\n default: str|None, the default value of the flag.\n enum_values: [str], a non-empty list of strings with the possible values for\n the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to Flag __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be any string from enum_values.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_enum_class", "docs": "Registers a flag whose value can be the name of enum members.\n\n Args:\n name: str, the flag name.\n default: Enum|str|None, the default value of the flag.\n enum_class: class, the Enum class with all the possible values for the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n case_sensitive: bool, whether to map strings to members of the enum_class\n without considering case.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to Flag __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be the name of enum members.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_flag", "docs": "Registers a 'Flag' object with a 'FlagValues' object.\n\n By default, the global FLAGS 'FlagValue' object is used.\n\n Typical users will use one of the more specialized DEFINE_xxx\n functions, such as DEFINE_string or DEFINE_integer. But developers\n who need to create Flag objects themselves should use this function\n to register their flags.\n\n Args:\n flag: Flag, a flag that is key to the module.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag. If not\n provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a 'Flag' object with a 'FlagValues' object.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_float", "docs": "Registers a flag whose value must be a float.\n\n If lower_bound or upper_bound are set, then this flag must be\n within the given range.\n\n Args:\n name: str, the flag name.\n default: float|str|None, the default value of the flag.\n help: str, the help message.\n lower_bound: float, min value of the flag.\n upper_bound: float, max value of the flag.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to DEFINE.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value must be a float.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_integer", "docs": "Registers a flag whose value must be an integer.\n\n If lower_bound, or upper_bound are set, then this flag must be\n within the given range.\n\n Args:\n name: str, the flag name.\n default: int|str|None, the default value of the flag.\n help: str, the help message.\n lower_bound: int, min value of the flag.\n upper_bound: int, max value of the flag.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: dict, the extra keyword args that are passed to DEFINE.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value must be an integer.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_list", "docs": "Registers a flag whose value is a comma-separated list of strings.\n\n The flag value is parsed with a CSV parser.\n\n Args:\n name: str, the flag name.\n default: list|str|None, the default value of the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value is a comma-separated list of strings.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi", "docs": "Registers a generic MultiFlag that parses its args with a given parser.\n\n Auxiliary function. Normal users should NOT use it directly.\n\n Developers who need to create their own 'Parser' classes for options\n which can appear multiple times can call this module function to\n register their flags.\n\n Args:\n parser: ArgumentParser, used to parse the flag arguments.\n serializer: ArgumentSerializer, the flag serializer instance.\n name: str, the flag name.\n default: Union[Iterable[T], Text, None], the default value of the flag. If\n the value is text, it will be parsed as if it was provided from the\n command line. If the value is a non-string iterable, it will be iterated\n over to create a shallow copy of the values. If it is None, it is left\n as-is.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: A string, the name of the Python module declaring this flag. If\n not provided, it will be computed using the stack trace of this call.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a generic MultiFlag that parses its args with a given parser.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi_enum", "docs": "Registers a flag whose value can be a list strings from enum_values.\n\n Use the flag on the command line multiple times to place multiple\n enum values into the list. The 'default' may be a single string\n (which will be converted into a single-element list) or a list of\n strings.\n\n Args:\n name: str, the flag name.\n default: Union[Iterable[Text], Text, None], the default value of the flag;\n see `DEFINE_multi`.\n enum_values: [str], a non-empty list of strings with the possible values for\n the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n case_sensitive: Whether or not the enum is to be case-sensitive.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be a list strings from enum_values.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi_enum_class", "docs": "Registers a flag whose value can be a list of enum members.\n\n Use the flag on the command line multiple times to place multiple\n enum values into the list.\n\n Args:\n name: str, the flag name.\n default: Union[Iterable[Enum], Iterable[Text], Enum, Text, None], the\n default value of the flag; see `DEFINE_multi`; only differences are\n documented here. If the value is a single Enum, it is treated as a\n single-item list of that Enum value. If it is an iterable, text values\n within the iterable will be converted to the equivalent Enum objects.\n enum_class: class, the Enum class with all the possible values for the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n module_name: A string, the name of the Python module declaring this flag. If\n not provided, it will be computed using the stack trace of this call.\n case_sensitive: bool, whether to map strings to members of the enum_class\n without considering case.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be a list of enum members.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi_float", "docs": "Registers a flag whose value can be a list of arbitrary floats.\n\n Use the flag on the command line multiple times to place multiple\n float values into the list. The 'default' may be a single float\n (which will be converted into a single-element list) or a list of\n floats.\n\n Args:\n name: str, the flag name.\n default: Union[Iterable[float], Text, None], the default value of the flag;\n see `DEFINE_multi`.\n help: str, the help message.\n lower_bound: float, min values of the flag.\n upper_bound: float, max values of the flag.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be a list of arbitrary floats.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi_integer", "docs": "Registers a flag whose value can be a list of arbitrary integers.\n\n Use the flag on the command line multiple times to place multiple\n integer values into the list. The 'default' may be a single integer\n (which will be converted into a single-element list) or a list of\n integers.\n\n Args:\n name: str, the flag name.\n default: Union[Iterable[int], Text, None], the default value of the flag;\n see `DEFINE_multi`.\n help: str, the help message.\n lower_bound: int, min values of the flag.\n upper_bound: int, max values of the flag.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be a list of arbitrary integers.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_multi_string", "docs": "Registers a flag whose value can be a list of any strings.\n\n Use the flag on the command line multiple times to place multiple\n string values into the list. The 'default' may be a single string\n (which will be converted into a single-element list) or a list of\n strings.\n\n\n Args:\n name: str, the flag name.\n default: Union[Iterable[Text], Text, None], the default value of the flag;\n see `DEFINE_multi`.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value can be a list of any strings.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_spaceseplist", "docs": "Registers a flag whose value is a whitespace-separated list of strings.\n\n Any whitespace can be used as a separator.\n\n Args:\n name: str, the flag name.\n default: list|str|None, the default value of the flag.\n help: str, the help message.\n comma_compat: bool - Whether to support comma as an additional separator. If\n false then only whitespace is supported. This is intended only for\n backwards compatibility with flags that used to be comma-separated.\n flag_values: FlagValues, the FlagValues instance with which the flag will be\n registered. This should almost never need to be overridden.\n required: bool, is this a required flag. This must be used as a keyword\n argument.\n **args: Dictionary with extra keyword args that are passed to the Flag\n __init__.\n\n Returns:\n a handle to defined flag.\n ", "desc": "Registers a flag whose value is a whitespace-separated list of strings.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DEFINE_string", "docs": "Registers a flag whose value can be any string.", "desc": "Registers a flag whose value can be any string.", "type": "API"}, {"name": "tf.compat.v1.app.flags.disclaim_key_flags", "docs": "Declares that the current module will not define any more key flags.\n\n Normally, the module that calls the DEFINE_xxx functions claims the\n flag to be its key flag. This is undesirable for modules that\n define additional DEFINE_yyy functions with its own flag parsers and\n serializers, since that module will accidentally claim flags defined\n by DEFINE_yyy as its key flags. After calling this function, the\n module disclaims flag definitions thereafter, so the key flags will\n be correctly attributed to the caller of DEFINE_yyy.\n\n After calling this function, the module will not be able to define\n any more flags. This function will affect all FlagValues objects.\n ", "desc": "Declares that the current module will not define any more key flags.", "type": "API"}, {"name": "tf.compat.v1.app.flags.doc_to_help", "docs": "Takes a __doc__ string and reformats it as help.", "desc": "Takes a __doc__ string and reformats it as help.", "type": "API"}, {"name": "tf.compat.v1.app.flags.DuplicateFlagError", "docs": "Raised if there is a flag naming conflict.", "desc": "Raised if there is a flag naming conflict.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumClassFlag", "docs": "Basic enum flag; its value is an enum class's member.", "desc": "Basic enum flag; its value is an enum class's member.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumClassListSerializer", "docs": "A serializer for MultiEnumClass flags.\n\n This serializer simply joins the output of `EnumClassSerializer` using a\n provided seperator.\n ", "desc": "A serializer for MultiEnumClass flags.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumClassParser", "docs": "Parser of an Enum class member.", "desc": "Parser of an Enum class member.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumClassSerializer", "docs": "Class for generating string representations of an enum class flag value.", "desc": "Class for generating string representations of an enum class flag value.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumFlag", "docs": "Basic enum flag; its value can be any string from list of enum_values.", "desc": "Basic enum flag; its value can be any string from list of enum_values.", "type": "API"}, {"name": "tf.compat.v1.app.flags.EnumParser", "docs": "Parser of a string enum value (a string value from a given set).", "desc": "Parser of a string enum value (a string value from a given set).", "type": "API"}, {"name": "tf.compat.v1.app.flags.Error", "docs": "The base class for all flags errors.", "desc": "The base class for all flags errors.", "type": "API"}, {"name": "tf.compat.v1.app.flags.Flag", "docs": "Information about a command-line flag.\n\n 'Flag' objects define the following fields:\n .name - the name for this flag;\n .default - the default value for this flag;\n .default_unparsed - the unparsed default value for this flag.\n .default_as_str - default value as repr'd string, e.g., \"'true'\" (or None);\n .value - the most recent parsed value of this flag; set by parse();\n .help - a help string or None if no help is available;\n .short_name - the single letter alias for this flag (or None);\n .boolean - if 'true', this flag does not accept arguments;\n .present - true if this flag was parsed from command line flags;\n .parser - an ArgumentParser object;\n .serializer - an ArgumentSerializer object;\n .allow_override - the flag may be redefined without raising an error, and\n newly defined flag overrides the old one.\n .allow_override_cpp - use the flag from C++ if available; the flag\n definition is replaced by the C++ flag after init;\n .allow_hide_cpp - use the Python flag despite having a C++ flag with\n the same name (ignore the C++ flag);\n .using_default_value - the flag value has not been set by user;\n .allow_overwrite - the flag may be parsed more than once without raising\n an error, the last set value will be used;\n .allow_using_method_names - whether this flag can be defined even if it has\n a name that conflicts with a FlagValues method.\n\n The only public method of a 'Flag' object is parse(), but it is\n typically only called by a 'FlagValues' object. The parse() method is\n a thin wrapper around the 'ArgumentParser' parse() method. The parsed\n value is saved in .value, and the .present attribute is updated. If\n this flag was already present, an Error is raised.\n\n parse() is also called during __init__ to parse the default value and\n initialize the .value attribute. This enables other python modules to\n safely use flags even if the __main__ module neglects to parse the\n command line arguments. The .present attribute is cleared after\n __init__ parsing. If the default value is set to None, then the\n __init__ parsing step is skipped and the .value attribute is\n initialized to None.\n\n Note: The default value is also presented to the user in the help\n string, so it is important that it be a legal value for this flag.\n ", "desc": "Information about a command-line flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.flag_dict_to_args", "docs": "Convert a dict of values into process call parameters.\n\n This method is used to convert a dictionary into a sequence of parameters\n for a binary that parses arguments using this module.\n\n Args:\n flag_map: dict, a mapping where the keys are flag names (strings).\n values are treated according to their type:\n * If value is None, then only the name is emitted.\n * If value is True, then only the name is emitted.\n * If value is False, then only the name prepended with 'no' is emitted.\n * If value is a string then --name=value is emitted.\n * If value is a collection, this will emit --name=value1,value2,value3,\n unless the flag name is in multi_flags, in which case this will emit\n --name=value1 --name=value2 --name=value3.\n * Everything else is converted to string an passed as such.\n multi_flags: set, names (strings) of flags that should be treated as\n multi-flags.\n Yields:\n sequence of string suitable for a subprocess execution.\n ", "desc": "Convert a dict of values into process call parameters.", "type": "API"}, {"name": "tf.compat.v1.app.flags.FlagHolder", "docs": "Holds a defined flag.\n\n This facilitates a cleaner api around global state. Instead of\n\n ```\n flags.DEFINE_integer('foo', ...)\n flags.DEFINE_integer('bar', ...)\n ...\n def method():\n # prints parsed value of 'bar' flag\n print(flags.FLAGS.foo)\n # runtime error due to typo or possibly bad coding style.\n print(flags.FLAGS.baz)\n ```\n\n it encourages code like\n\n ```\n FOO_FLAG = flags.DEFINE_integer('foo', ...)\n BAR_FLAG = flags.DEFINE_integer('bar', ...)\n ...\n def method():\n print(FOO_FLAG.value)\n print(BAR_FLAG.value)\n ```\n\n since the name of the flag appears only once in the source code.\n ", "desc": "Holds a defined flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.FlagNameConflictsWithMethodError", "docs": "Raised when a flag name conflicts with FlagValues methods.", "desc": "Raised when a flag name conflicts with FlagValues methods.", "type": "API"}, {"name": "tf.compat.v1.app.flags.FLAGS", "docs": "Registry of 'Flag' objects.\n\n A 'FlagValues' can then scan command line arguments, passing flag\n arguments through to the 'Flag' objects that it owns. It also\n provides easy access to the flag values. Typically only one\n 'FlagValues' object is needed by an application: flags.FLAGS\n\n This class is heavily overloaded:\n\n 'Flag' objects are registered via __setitem__:\n FLAGS['longname'] = x # register a new flag\n\n The .value attribute of the registered 'Flag' objects can be accessed\n as attributes of this 'FlagValues' object, through __getattr__. Both\n the long and short name of the original 'Flag' objects can be used to\n access its value:\n FLAGS.longname # parsed flag value\n FLAGS.x # parsed flag value (short name)\n\n Command line arguments are scanned and passed to the registered 'Flag'\n objects through the __call__ method. Unparsed arguments, including\n argv[0] (e.g. the program name) are returned.\n argv = FLAGS(sys.argv) # scan command line arguments\n\n The original registered Flag objects can be retrieved through the use\n of the dictionary-like operator, __getitem__:\n x = FLAGS['longname'] # access the registered Flag object\n\n The str() operator of a 'FlagValues' object provides help for all of\n the registered 'Flag' objects.\n ", "desc": "Registry of 'Flag' objects.", "type": "API"}, {"name": "tf.compat.v1.app.flags.FlagValues", "docs": "Registry of 'Flag' objects.\n\n A 'FlagValues' can then scan command line arguments, passing flag\n arguments through to the 'Flag' objects that it owns. It also\n provides easy access to the flag values. Typically only one\n 'FlagValues' object is needed by an application: flags.FLAGS\n\n This class is heavily overloaded:\n\n 'Flag' objects are registered via __setitem__:\n FLAGS['longname'] = x # register a new flag\n\n The .value attribute of the registered 'Flag' objects can be accessed\n as attributes of this 'FlagValues' object, through __getattr__. Both\n the long and short name of the original 'Flag' objects can be used to\n access its value:\n FLAGS.longname # parsed flag value\n FLAGS.x # parsed flag value (short name)\n\n Command line arguments are scanned and passed to the registered 'Flag'\n objects through the __call__ method. Unparsed arguments, including\n argv[0] (e.g. the program name) are returned.\n argv = FLAGS(sys.argv) # scan command line arguments\n\n The original registered Flag objects can be retrieved through the use\n of the dictionary-like operator, __getitem__:\n x = FLAGS['longname'] # access the registered Flag object\n\n The str() operator of a 'FlagValues' object provides help for all of\n the registered 'Flag' objects.\n ", "desc": "Registry of 'Flag' objects.", "type": "API"}, {"name": "tf.compat.v1.app.flags.FloatParser", "docs": "Parser of floating point values.\n\n Parsed value may be bounded to a given upper and lower bound.\n ", "desc": "Parser of floating point values.", "type": "API"}, {"name": "tf.compat.v1.app.flags.get_help_width", "docs": "Returns the integer width of help lines that is used in TextWrap.", "desc": "Returns the integer width of help lines that is used in TextWrap.", "type": "API"}, {"name": "tf.compat.v1.app.flags.IllegalFlagValueError", "docs": "Raised when the flag command line argument is illegal.", "desc": "Raised when the flag command line argument is illegal.", "type": "API"}, {"name": "tf.compat.v1.app.flags.IntegerParser", "docs": "Parser of an integer value.\n\n Parsed value may be bounded to a given upper and lower bound.\n ", "desc": "Parser of an integer value.", "type": "API"}, {"name": "tf.compat.v1.app.flags.ListParser", "docs": "Parser for a comma-separated list of strings.", "desc": "Parser for a comma-separated list of strings.", "type": "API"}, {"name": "tf.compat.v1.app.flags.ListSerializer", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.app.flags.mark_bool_flags_as_mutual_exclusive", "docs": "Ensures that only one flag among flag_names is True.\n\n Args:\n flag_names: [str], names of the flags.\n required: bool. If true, exactly one flag must be True. Otherwise, at most\n one flag can be True, and it is valid for all flags to be False.\n flag_values: flags.FlagValues, optional FlagValues instance where the flags\n are defined.\n ", "desc": "Ensures that only one flag among flag_names is True.", "type": "API"}, {"name": "tf.compat.v1.app.flags.mark_flag_as_required", "docs": "Ensures that flag is not None during program execution.\n\n Registers a flag validator, which will follow usual validator rules.\n Important note: validator will pass for any non-None value, such as False,\n 0 (zero), '' (empty string) and so on.\n\n If your module might be imported by others, and you only wish to make the flag\n required when the module is directly executed, call this method like this:\n\n if __name__ == '__main__':\n flags.mark_flag_as_required('your_flag_name')\n app.run()\n\n Args:\n flag_name: str, name of the flag\n flag_values: flags.FlagValues, optional FlagValues instance where the flag\n is defined.\n Raises:\n AttributeError: Raised when flag_name is not registered as a valid flag\n name.\n ", "desc": "Ensures that flag is not None during program execution.", "type": "API"}, {"name": "tf.compat.v1.app.flags.mark_flags_as_mutual_exclusive", "docs": "Ensures that only one flag among flag_names is not None.\n\n Important note: This validator checks if flag values are None, and it does not\n distinguish between default and explicit values. Therefore, this validator\n does not make sense when applied to flags with default values other than None,\n including other false values (e.g. False, 0, '', []). That includes multi\n flags with a default value of [] instead of None.\n\n Args:\n flag_names: [str], names of the flags.\n required: bool. If true, exactly one of the flags must have a value other\n than None. Otherwise, at most one of the flags can have a value other\n than None, and it is valid for all of the flags to be None.\n flag_values: flags.FlagValues, optional FlagValues instance where the flags\n are defined.\n ", "desc": "Ensures that only one flag among flag_names is not None.", "type": "API"}, {"name": "tf.compat.v1.app.flags.mark_flags_as_required", "docs": "Ensures that flags are not None during program execution.\n\n If your module might be imported by others, and you only wish to make the flag\n required when the module is directly executed, call this method like this:\n\n if __name__ == '__main__':\n flags.mark_flags_as_required(['flag1', 'flag2', 'flag3'])\n app.run()\n\n Args:\n flag_names: Sequence[str], names of the flags.\n flag_values: flags.FlagValues, optional FlagValues instance where the flags\n are defined.\n Raises:\n AttributeError: If any of flag name has not already been defined as a flag.\n ", "desc": "Ensures that flags are not None during program execution.", "type": "API"}, {"name": "tf.compat.v1.app.flags.multi_flags_validator", "docs": "A function decorator for defining a multi-flag validator.\n\n Registers the decorated function as a validator for flag_names, e.g.\n\n @flags.multi_flags_validator(['foo', 'bar'])\n def _CheckFooBar(flags_dict):\n ...\n\n See register_multi_flags_validator() for the specification of checker\n function.\n\n Args:\n flag_names: [str], a list of the flag names to be checked.\n message: str, error text to be shown to the user if checker returns False.\n If checker raises flags.ValidationError, message from the raised\n error will be shown.\n flag_values: flags.FlagValues, optional FlagValues instance to validate\n against.\n\n Returns:\n A function decorator that registers its function argument as a validator.\n\n Raises:\n AttributeError: Raised when a flag is not registered as a valid flag name.\n ", "desc": "A function decorator for defining a multi-flag validator.", "type": "API"}, {"name": "tf.compat.v1.app.flags.MultiEnumClassFlag", "docs": "A multi_enum_class flag.\n\n See the __doc__ for MultiFlag for most behaviors of this class. In addition,\n this class knows how to handle enum.Enum instances as values for this flag\n type.\n ", "desc": "A multi_enum_class flag.", "type": "API"}, {"name": "tf.compat.v1.app.flags.MultiFlag", "docs": "A flag that can appear multiple time on the command-line.\n\n The value of such a flag is a list that contains the individual values\n from all the appearances of that flag on the command-line.\n\n See the __doc__ for Flag for most behavior of this class. Only\n differences in behavior are described here:\n\n * The default value may be either a single value or an iterable of values.\n A single value is transformed into a single-item list of that value.\n\n * The value of the flag is always a list, even if the option was\n only supplied once, and even if the default value is a single\n value\n ", "desc": "A flag that can appear multiple time on the command-line.", "type": "API"}, {"name": "tf.compat.v1.app.flags.register_multi_flags_validator", "docs": "Adds a constraint to multiple flags.\n\n The constraint is validated when flags are initially parsed, and after each\n change of the corresponding flag's value.\n\n Args:\n flag_names: [str], a list of the flag names to be checked.\n multi_flags_checker: callable, a function to validate the flag.\n input - dict, with keys() being flag_names, and value for each key\n being the value of the corresponding flag (string, boolean, etc).\n output - bool, True if validator constraint is satisfied.\n If constraint is not satisfied, it should either return False or\n raise flags.ValidationError.\n message: str, error text to be shown to the user if checker returns False.\n If checker raises flags.ValidationError, message from the raised\n error will be shown.\n flag_values: flags.FlagValues, optional FlagValues instance to validate\n against.\n\n Raises:\n AttributeError: Raised when a flag is not registered as a valid flag name.\n ", "desc": "Adds a constraint to multiple flags.", "type": "API"}, {"name": "tf.compat.v1.app.flags.register_validator", "docs": "Adds a constraint, which will be enforced during program execution.\n\n The constraint is validated when flags are initially parsed, and after each\n change of the corresponding flag's value.\n Args:\n flag_name: str, name of the flag to be checked.\n checker: callable, a function to validate the flag.\n input - A single positional argument: The value of the corresponding\n flag (string, boolean, etc. This value will be passed to checker\n by the library).\n output - bool, True if validator constraint is satisfied.\n If constraint is not satisfied, it should either return False or\n raise flags.ValidationError(desired_error_message).\n message: str, error text to be shown to the user if checker returns False.\n If checker raises flags.ValidationError, message from the raised\n error will be shown.\n flag_values: flags.FlagValues, optional FlagValues instance to validate\n against.\n Raises:\n AttributeError: Raised when flag_name is not registered as a valid flag\n name.\n ", "desc": "Adds a constraint, which will be enforced during program execution.", "type": "API"}, {"name": "tf.compat.v1.app.flags.text_wrap", "docs": "Wraps a given text to a maximum line length and returns it.\n\n It turns lines that only contain whitespace into empty lines, keeps new lines,\n and expands tabs using 4 spaces.\n\n Args:\n text: str, text to wrap.\n length: int, maximum length of a line, includes indentation.\n If this is None then use get_help_width()\n indent: str, indent for all but first line.\n firstline_indent: str, indent for first line; if None, fall back to indent.\n\n Returns:\n str, the wrapped text.\n\n Raises:\n ValueError: Raised if indent or firstline_indent not shorter than length.\n ", "desc": "Wraps a given text to a maximum line length and returns it.", "type": "API"}, {"name": "tf.compat.v1.app.flags.tf_decorator", "docs": "Base TFDecorator class and utility functions for working with decorators.\n\nThere are two ways to create decorators that TensorFlow can introspect into.\nThis is important for documentation generation purposes, so that function\nsignatures aren't obscured by the (*args, **kwds) signature that decorators\noften provide.\n\n1. Call `tf_decorator.make_decorator` on your wrapper function. If your\ndecorator is stateless, or can capture all of the variables it needs to work\nwith through lexical closure, this is the simplest option. Create your wrapper\nfunction as usual, but instead of returning it, return\n`tf_decorator.make_decorator(target, your_wrapper)`. This will attach some\ndecorator introspection metadata onto your wrapper and return it.\n\nExample:\n\n def print_hello_before_calling(target):\n def wrapper(*args, **kwargs):\n print('hello')\n return target(*args, **kwargs)\n return tf_decorator.make_decorator(target, wrapper)\n\n2. Derive from TFDecorator. If your decorator needs to be stateful, you can\nimplement it in terms of a TFDecorator. Store whatever state you need in your\nderived class, and implement the `__call__` method to do your work before\ncalling into your target. You can retrieve the target via\n`super(MyDecoratorClass, self).decorated_target`, and call it with whatever\nparameters it needs.\n\nExample:\n\n class CallCounter(tf_decorator.TFDecorator):\n def __init__(self, target):\n super(CallCounter, self).__init__('count_calls', target)\n self.call_count = 0\n\n def __call__(self, *args, **kwargs):\n self.call_count += 1\n return super(CallCounter, self).decorated_target(*args, **kwargs)\n\n def count_calls(target):\n return CallCounter(target)\n", "desc": "Base TFDecorator class and utility functions for working with decorators.", "type": "API"}, {"name": "tf.compat.v1.app.flags.tf_decorator.make_decorator", "docs": "Make a decorator from a wrapper and a target.\n\n Args:\n target: The final callable to be wrapped.\n decorator_func: The wrapper function.\n decorator_name: The name of the decorator. If `None`, the name of the\n function calling make_decorator.\n decorator_doc: Documentation specific to this application of\n `decorator_func` to `target`.\n decorator_argspec: The new callable signature of this decorator.\n\n Returns:\n The `decorator_func` argument with new metadata attached.\n ", "desc": "Make a decorator from a wrapper and a target.", "type": "API"}, {"name": "tf.compat.v1.app.flags.tf_decorator.rewrap", "docs": "Injects a new target into a function built by make_decorator.\n\n This function allows replacing a function wrapped by `decorator_func`,\n assuming the decorator that wraps the function is written as described below.\n\n The decorator function must use `.__wrapped__` instead of the\n wrapped function that is normally used:\n\n Example:\n\n # Instead of this:\n def simple_parametrized_wrapper(*args, **kwds):\n return wrapped_fn(*args, **kwds)\n\n tf_decorator.make_decorator(simple_parametrized_wrapper, wrapped_fn)\n\n # Write this:\n def simple_parametrized_wrapper(*args, **kwds):\n return simple_parametrized_wrapper.__wrapped__(*args, **kwds)\n\n tf_decorator.make_decorator(simple_parametrized_wrapper, wrapped_fn)\n\n Note that this process modifies decorator_func.\n\n Args:\n decorator_func: Callable returned by `wrap`.\n previous_target: Callable that needs to be replaced.\n new_target: Callable to replace previous_target with.\n\n Returns:\n The updated decorator. If decorator_func is not a tf_decorator, new_target\n is returned.\n ", "desc": "Injects a new target into a function built by make_decorator.", "type": "API"}, {"name": "tf.compat.v1.app.flags.tf_decorator.TFDecorator", "docs": "Base class for all TensorFlow decorators.\n\n TFDecorator captures and exposes the wrapped target, and provides details\n about the current decorator.\n ", "desc": "Base class for all TensorFlow decorators.", "type": "API"}, {"name": "tf.compat.v1.app.flags.tf_decorator.unwrap", "docs": "Unwraps an object into a list of TFDecorators and a final target.\n\n Args:\n maybe_tf_decorator: Any callable object.\n\n Returns:\n A tuple whose first element is an list of TFDecorator-derived objects that\n were applied to the final callable target, and whose second element is the\n final undecorated callable target. If the `maybe_tf_decorator` parameter is\n not decorated by any TFDecorators, the first tuple element will be an empty\n list. The `TFDecorator` list is ordered from outermost to innermost\n decorators.\n ", "desc": "Unwraps an object into a list of TFDecorators and a final target.", "type": "API"}, {"name": "tf.compat.v1.app.flags.UnparsedFlagAccessError", "docs": "Raised when accessing the flag value from unparsed FlagValues.", "desc": "Raised when accessing the flag value from unparsed FlagValues.", "type": "API"}, {"name": "tf.compat.v1.app.flags.UnrecognizedFlagError", "docs": "Raised when a flag is unrecognized.\n\n Attributes:\n flagname: str, the name of the unrecognized flag.\n flagvalue: The value of the flag, empty if the flag is not defined.\n ", "desc": "Raised when a flag is unrecognized.", "type": "API"}, {"name": "tf.compat.v1.app.flags.ValidationError", "docs": "Raised when flag validator constraint is not satisfied.", "desc": "Raised when flag validator constraint is not satisfied.", "type": "API"}, {"name": "tf.compat.v1.app.flags.validator", "docs": "A function decorator for defining a flag validator.\n\n Registers the decorated function as a validator for flag_name, e.g.\n\n @flags.validator('foo')\n def _CheckFoo(foo):\n ...\n\n See register_validator() for the specification of checker function.\n\n Args:\n flag_name: str, name of the flag to be checked.\n message: str, error text to be shown to the user if checker returns False.\n If checker raises flags.ValidationError, message from the raised\n error will be shown.\n flag_values: flags.FlagValues, optional FlagValues instance to validate\n against.\n Returns:\n A function decorator that registers its function argument as a validator.\n Raises:\n AttributeError: Raised when flag_name is not registered as a valid flag\n name.\n ", "desc": "A function decorator for defining a flag validator.", "type": "API"}, {"name": "tf.compat.v1.app.flags.WhitespaceSeparatedListParser", "docs": "Parser for a whitespace-separated list of strings.", "desc": "Parser for a whitespace-separated list of strings.", "type": "API"}, {"name": "tf.compat.v1.app.run", "docs": "Runs the program with an optional 'main' function and 'argv' list.", "desc": "Runs the program with an optional 'main' function and 'argv' list.", "type": "API"}, {"name": "tf.compat.v1.arg_max", "docs": "Returns the index with the largest value across dimensions of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Usage:\n ```python\n import tensorflow as tf\n a = [1, 10, 26.9, 2.8, 166.32, 62.3]\n b = tf.math.argmax(input = a)\n c = tf.keras.backend.eval(b)\n # c = 4\n # here a[4] = 166.32 which is the largest element of a across axis 0\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`.\n dimension: A `Tensor`. Must be one of the following types: `int16`, `int32`, `int64`.\n int16, int32 or int64, must be in the range `[-rank(input), rank(input))`.\n Describes which dimension of the input Tensor to reduce across. For vectors,\n use dimension = 0.\n output_type: An optional `tf.DType` from: `tf.int16, tf.uint16, tf.int32, tf.int64`. Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n ", "desc": "Returns the index with the largest value across dimensions of a tensor.", "type": "API"}, {"name": "tf.compat.v1.arg_min", "docs": "Returns the index with the smallest value across dimensions of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Usage:\n ```python\n import tensorflow as tf\n a = [1, 10, 26.9, 2.8, 166.32, 62.3]\n b = tf.math.argmin(input = a)\n c = tf.keras.backend.eval(b)\n # c = 0\n # here a[0] = 1 which is the smallest element of a across axis 0\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`.\n dimension: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `[-rank(input), rank(input))`.\n Describes which dimension of the input Tensor to reduce across. For vectors,\n use dimension = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n ", "desc": "Returns the index with the smallest value across dimensions of a tensor.", "type": "API"}, {"name": "tf.compat.v1.argmax", "docs": "Returns the index with the largest value across axes of a tensor. (deprecated arguments)\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(dimension)`. They will be removed in a future version.\nInstructions for updating:\nUse the `axis` argument instead\n\nNote that in case of ties the identity of the return value is not guaranteed.\n\nUsage:\n ```python\n import tensorflow as tf\n a = [1, 10, 26.9, 2.8, 166.32, 62.3]\n b = tf.math.argmax(input = a)\n c = tf.keras.backend.eval(b)\n # c = 4\n # here a[4] = 166.32 which is the largest element of a across axis 0\n ```\n\nArgs:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`.\n axis: A `Tensor`. Must be one of the following types: `int16`, `int32`, `int64`.\n int16, int32 or int64, must be in the range `[-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int16, tf.uint16, tf.int32, tf.int64`. Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\nReturns:\n A `Tensor` of type `output_type`.", "desc": "Returns the index with the largest value across axes of a tensor. (deprecated arguments)", "type": "API"}, {"name": "tf.compat.v1.argmin", "docs": "Returns the index with the smallest value across axes of a tensor. (deprecated arguments)\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(dimension)`. They will be removed in a future version.\nInstructions for updating:\nUse the `axis` argument instead\n\nNote that in case of ties the identity of the return value is not guaranteed.\n\nUsage:\n ```python\n import tensorflow as tf\n a = [1, 10, 26.9, 2.8, 166.32, 62.3]\n b = tf.math.argmin(input = a)\n c = tf.keras.backend.eval(b)\n # c = 0\n # here a[0] = 1 which is the smallest element of a across axis 0\n ```\n\nArgs:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `[-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\nReturns:\n A `Tensor` of type `output_type`.", "desc": "Returns the index with the smallest value across axes of a tensor. (deprecated arguments)", "type": "API"}, {"name": "tf.compat.v1.argsort", "docs": "Returns the indices of a tensor that give its sorted order along an axis.\n\n >>> values = [1, 10, 26.9, 2.8, 166.32, 62.3]\n >>> sort_order = tf.argsort(values)\n >>> sort_order.numpy()\n array([0, 3, 1, 2, 5, 4], dtype=int32)\n\n For a 1D tensor:\n\n >>> sorted = tf.gather(values, sort_order)\n >>> assert tf.reduce_all(sorted == tf.sort(values))\n\n For higher dimensions, the output has the same shape as\n `values`, but along the given axis, values represent the index of the sorted\n element in that slice of the tensor at the given position.\n\n >>> mat = [[30,20,10],\n ... [20,10,30],\n ... [10,30,20]]\n >>> indices = tf.argsort(mat)\n >>> indices.numpy()\n array([[2, 1, 0],\n [1, 0, 2],\n [0, 2, 1]], dtype=int32)\n\n If `axis=-1` these indices can be used to apply a sort using `tf.gather`:\n\n >>> tf.gather(mat, indices, batch_dims=-1).numpy()\n array([[10, 20, 30],\n [10, 20, 30],\n [10, 20, 30]], dtype=int32)\n\n See also:\n\n * `tf.sort`: Sort along an axis.\n * `tf.math.top_k`: A partial sort that returns a fixed number of top values\n and corresponding indices.\n\n Args:\n values: 1-D or higher **numeric** `Tensor`.\n axis: The axis along which to sort. The default is -1, which sorts the last\n axis.\n direction: The direction in which to sort the values (`'ASCENDING'` or\n `'DESCENDING'`).\n stable: If True, equal elements in the original tensor will not be\n re-ordered in the returned order. Unstable sort is not yet implemented,\n but will eventually be the default for performance reasons. If you require\n a stable order, pass `stable=True` for forwards compatibility.\n name: Optional name for the operation.\n\n Returns:\n An int32 `Tensor` with the same shape as `values`. The indices that would\n sort each slice of the given `values` along the given `axis`.\n\n Raises:\n ValueError: If axis is not a constant scalar, or the direction is invalid.\n tf.errors.InvalidArgumentError: If the `values.dtype` is not a `float` or\n `int` type.\n ", "desc": "Returns the indices of a tensor that give its sorted order along an axis.", "type": "API"}, {"name": "tf.compat.v1.as_dtype", "docs": "Converts the given `type_value` to a `DType`.\n\n Note: `DType` values are interned. When passed a new `DType` object,\n `as_dtype` always returns the interned value.\n\n Args:\n type_value: A value that can be converted to a `tf.DType` object. This may\n currently be a `tf.DType` object, a [`DataType`\n enum](https://www.tensorflow.org/code/tensorflow/core/framework/types.proto),\n a string type name, or a [`numpy.dtype`](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html).\n\n Returns:\n A `DType` corresponding to `type_value`.\n\n Raises:\n TypeError: If `type_value` cannot be converted to a `DType`.\n ", "desc": "Converts the given `type_value` to a `DType`.", "type": "API"}, {"name": "tf.compat.v1.as_string", "docs": "Converts each entry in the given tensor to strings.\n\n Supports many numeric types and boolean.\n\n For Unicode, see the\n [https://www.tensorflow.org/tutorials/representation/unicode](Working with Unicode text)\n tutorial.\n\n Examples:\n\n >>> tf.strings.as_string([3, 2])\n \n >>> tf.strings.as_string([3.1415926, 2.71828], precision=2).numpy()\n array([b'3.14', b'2.72'], dtype=object)\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `complex64`, `complex128`, `bool`, `variant`.\n precision: An optional `int`. Defaults to `-1`.\n The post-decimal precision to use for floating point numbers.\n Only used if precision > -1.\n scientific: An optional `bool`. Defaults to `False`.\n Use scientific notation for floating point numbers.\n shortest: An optional `bool`. Defaults to `False`.\n Use shortest representation (either scientific or standard) for\n floating point numbers.\n width: An optional `int`. Defaults to `-1`.\n Pad pre-decimal numbers to this width.\n Applies to both floating point and integer numbers.\n Only used if width > -1.\n fill: An optional `string`. Defaults to `\"\"`.\n The value to pad if width > -1. If empty, pads with spaces.\n Another typical value is '0'. String cannot be longer than 1 character.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Converts each entry in the given tensor to strings.", "type": "API"}, {"name": "tf.compat.v1.asin", "docs": "Computes the trignometric inverse sine of x element-wise.\n\n The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that\n if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.\n\n **Note**: The output of `tf.math.asin` will lie within the invertible range\n of sine, i.e [-pi/2, pi/2].\n\n For example:\n\n ```python\n # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]\n x = tf.constant([1.047, 0.785])\n y = tf.math.sin(x) # [0.8659266, 0.7068252]\n\n tf.math.asin(y) # [1.047, 0.785] = x\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes the trignometric inverse sine of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.asinh", "docs": "Computes inverse hyperbolic sine of x element-wise.\n\n Given an input tensor, this function computes inverse hyperbolic sine\n for every element in the tensor. Both input and output has a range of\n `[-inf, inf]`.\n\n ```python\n x = tf.constant([-float(\"inf\"), -2, -0.5, 1, 1.2, 200, 10000, float(\"inf\")])\n tf.math.asinh(x) ==> [-inf -1.4436355 -0.4812118 0.8813736 1.0159732 5.991471 9.903487 inf]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic sine of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.Assert", "docs": "Asserts that the given condition is true.\n\nIf `condition` evaluates to false, print the list of tensors in `data`.\n`summarize` determines how many entries of the tensors to print.\n\nArgs:\n condition: The condition to evaluate.\n data: The tensors to print out when condition is false.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional).\n\nReturns:\n assert_op: An `Operation` that, when executed, raises a\n `tf.errors.InvalidArgumentError` if `condition` is not true.\n @compatibility(eager)\n returns None\n @end_compatibility\n\nRaises:\n @compatibility(TF1)\n When in TF V1 mode (that is, outside `tf.function`) Assert needs a control\n dependency on the output to ensure the assertion executes:\n\n```python\n# Ensure maximum element of x is smaller or equal to 1\nassert_op = tf.Assert(tf.less_equal(tf.reduce_max(x), 1.), [x])\nwith tf.control_dependencies([assert_op]):\n ... code using x ...\n```\n\n @end_compatibility\n\n\nNote: The output of this function should be used. If it is not, a warning will be logged or an error may be raised. To mark the output as used, call its .mark_used() method.", "desc": "Asserts that the given condition is true.", "type": "API"}, {"name": "tf.compat.v1.assert_equal", "docs": "\n Assert the condition `x == y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] == y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x == y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x == y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_equal(a, b,\n ... message='\"a == b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 2]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 2], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_equal(a, b, message=\n ... '\"a == b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_greater", "docs": "\n Assert the condition `x > y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] > y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_greater(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_greater\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x > y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x > y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_greater` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_greater` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_greater(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_greater(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_greater(a, b,\n ... message='\"a > b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[0, 1]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([0, 1], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_greater(a, b, message=\n ... '\"a > b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_greater_equal", "docs": "\n Assert the condition `x >= y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] >= y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_greater_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_greater_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x >= y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x >= y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_greater_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_greater_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_greater_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_greater_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_greater_equal(a, b,\n ... message='\"a >= b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 0]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 0], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_greater_equal(a, b, message=\n ... '\"a >= b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_integer", "docs": "Assert that `x` is of integer dtype.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_integer(x)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: `Tensor` whose basetype is integer and is not quantized.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_integer\".\n\n Raises:\n TypeError: If `x.dtype` is anything other than non-quantized integer.\n\n Returns:\n A `no_op` that does nothing. Type can be determined statically.\n ", "desc": "Assert that `x` is of integer dtype.", "type": "API"}, {"name": "tf.compat.v1.assert_less", "docs": "\n Assert the condition `x < y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] < y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_less(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_less\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x < y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x < y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_less` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_less` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_less(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_less(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_less(a, b,\n ... message='\"a < b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[2, 3]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([2, 3], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_less(a, b, message=\n ... '\"a < b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_less_equal", "docs": "\n Assert the condition `x <= y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] <= y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_less_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_less_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x <= y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x <= y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_less_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_less_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_less_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_less_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_less_equal(a, b,\n ... message='\"a <= b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 3]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 3], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_less_equal(a, b, message=\n ... '\"a <= b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_near", "docs": "Assert the condition `x` and `y` are close element-wise.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_near(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have\n\n ```tf.abs(x[i] - y[i]) <= atol + rtol * tf.abs(y[i])```.\n\n If both `x` and `y` are empty, this is trivially satisfied.\n\n The default `atol` and `rtol` is `10 * eps`, where `eps` is the smallest\n representable positive number such that `1 + eps != 1`. This is about\n `1.2e-6` in `32bit`, `2.22e-15` in `64bit`, and `0.00977` in `16bit`.\n See `numpy.finfo`.\n\n Args:\n x: Float or complex `Tensor`.\n y: Float or complex `Tensor`, same `dtype` as, and broadcastable to, `x`.\n rtol: `Tensor`. Same `dtype` as, and broadcastable to, `x`.\n The relative tolerance. Default is `10 * eps`.\n atol: `Tensor`. Same `dtype` as, and broadcastable to, `x`.\n The absolute tolerance. Default is `10 * eps`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_near\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x` and `y` are not close enough.\n\n @compatibility(numpy)\n Similar to `numpy.testing.assert_allclose`, except tolerance depends on data\n type. This is due to the fact that `TensorFlow` is often used with `32bit`,\n `64bit`, and even `16bit` data.\n @end_compatibility\n ", "desc": "Assert the condition `x` and `y` are close element-wise.", "type": "API"}, {"name": "tf.compat.v1.assert_negative", "docs": "\n Assert the condition `x < 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_negative(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Negative means, for every element `x[i]` of `x`, we have `x[i] < 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_negative\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x < 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x < 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_non_negative", "docs": "\n Assert the condition `x >= 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_non_negative(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Non-negative means, for every element `x[i]` of `x`, we have `x[i] >= 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_non_negative\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x >= 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x >= 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_non_positive", "docs": "\n Assert the condition `x <= 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_non_positive(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Non-positive means, for every element `x[i]` of `x`, we have `x[i] <= 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_non_positive\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x <= 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x <= 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_none_equal", "docs": "\n Assert the condition `x != y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] != y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_none_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_none_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x != y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x != y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_none_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_none_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_none_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_none_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_none_equal(a, b,\n ... message='\"a != b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[2, 1]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([2, 1], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_none_equal(a, b, message=\n ... '\"a != b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_positive", "docs": "\n Assert the condition `x > 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_positive(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Positive means, for every element `x[i]` of `x`, we have `x[i] > 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_positive\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x > 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x > 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.assert_proper_iterable", "docs": "Static assert that values is a \"proper\" iterable.\n\n `Ops` that expect iterables of `Tensor` can call this to validate input.\n Useful since `Tensor`, `ndarray`, byte/text type are all iterables themselves.\n\n Args:\n values: Object to be checked.\n\n Raises:\n TypeError: If `values` is not iterable or is one of\n `Tensor`, `SparseTensor`, `np.array`, `tf.compat.bytes_or_text_types`.\n ", "desc": "Static assert that values is a \"proper\" iterable.", "type": "API"}, {"name": "tf.compat.v1.assert_rank", "docs": "Assert `x` has rank equal to `rank`.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank(x, 2)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n rank: Scalar integer `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and the shape of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_rank\".\n\n Returns:\n Op raising `InvalidArgumentError` unless `x` has specified rank.\n If static checks determine `x` has correct rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has wrong rank.\n ", "desc": "Assert `x` has rank equal to `rank`.", "type": "API"}, {"name": "tf.compat.v1.assert_rank_at_least", "docs": "Assert `x` has rank equal to `rank` or higher.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank_at_least(x, 2)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n rank: Scalar `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional).\n Defaults to \"assert_rank_at_least\".\n\n Returns:\n Op raising `InvalidArgumentError` unless `x` has specified rank or higher.\n If static checks determine `x` has correct rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has wrong rank.\n ", "desc": "Assert `x` has rank equal to `rank` or higher.", "type": "API"}, {"name": "tf.compat.v1.assert_rank_in", "docs": "Assert `x` has rank in `ranks`.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank_in(x, (2, 4))]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n ranks: Iterable of scalar `Tensor` objects.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional).\n Defaults to \"assert_rank_in\".\n\n Returns:\n Op raising `InvalidArgumentError` unless rank of `x` is in `ranks`.\n If static checks determine `x` has matching rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has mismatched rank.\n ", "desc": "Assert `x` has rank in `ranks`.", "type": "API"}, {"name": "tf.compat.v1.assert_same_float_dtype", "docs": "Validate and return float type based on `tensors` and `dtype`.\n\n For ops such as matrix multiplication, inputs and weights must be of the\n same float type. This function validates that all `tensors` are the same type,\n validates that type is `dtype` (if supplied), and returns the type. Type must\n be a floating point type. If neither `tensors` nor `dtype` is supplied,\n the function will return `dtypes.float32`.\n\n Args:\n tensors: Tensors of input values. Can include `None` elements, which will be\n ignored.\n dtype: Expected type.\n\n Returns:\n Validated type.\n\n Raises:\n ValueError: if neither `tensors` nor `dtype` is supplied, or result is not\n float, or the common type of the inputs is not a floating point type.\n ", "desc": "Validate and return float type based on `tensors` and `dtype`.", "type": "API"}, {"name": "tf.compat.v1.assert_scalar", "docs": "Asserts that the given `tensor` is a scalar (i.e. zero-dimensional).\n\n This function raises `ValueError` unless it can be certain that the given\n `tensor` is a scalar. `ValueError` is also raised if the shape of `tensor` is\n unknown.\n\n Args:\n tensor: A `Tensor`.\n name: A name for this operation. Defaults to \"assert_scalar\"\n message: A string to prefix to the default message.\n\n Returns:\n The input tensor (potentially converted to a `Tensor`).\n\n Raises:\n ValueError: If the tensor is not scalar (rank 0), or if its shape is\n unknown.\n ", "desc": "Asserts that the given `tensor` is a scalar (i.e. zero-dimensional).", "type": "API"}, {"name": "tf.compat.v1.assert_type", "docs": "Statically asserts that the given `Tensor` is of the specified type.\n\n Args:\n tensor: A `Tensor` or `SparseTensor`.\n tf_type: A tensorflow type (`dtypes.float32`, `tf.int64`, `dtypes.bool`,\n etc).\n message: A string to prefix to the default message.\n name: A name to give this `Op`. Defaults to \"assert_type\"\n\n Raises:\n TypeError: If the tensors data type doesn't match `tf_type`.\n\n Returns:\n A `no_op` that does nothing. Type can be determined statically.\n ", "desc": "Statically asserts that the given `Tensor` is of the specified type.", "type": "API"}, {"name": "tf.compat.v1.assert_variables_initialized", "docs": "Returns an Op to check if variables are initialized.\n\nNOTE: This function is obsolete and will be removed in 6 months. Please\nchange your implementation to use `report_uninitialized_variables()`.\n\nWhen run, the returned Op will raise the exception `FailedPreconditionError`\nif any of the variables has not yet been initialized.\n\nNote: This function is implemented by trying to fetch the values of the\nvariables. If one of the variables is not initialized a message may be\nlogged by the C++ runtime. This is expected.\n\nArgs:\n var_list: List of `Variable` objects to check. Defaults to the value of\n `global_variables().`\n\nReturns:\n An Op, or None if there are no variables.\n\n\nNote: The output of this function should be used. If it is not, a warning will be logged or an error may be raised. To mark the output as used, call its .mark_used() method.", "desc": "Returns an Op to check if variables are initialized.", "type": "API"}, {"name": "tf.compat.v1.assign", "docs": "Update `ref` by assigning `value` to it.\n\n This operation outputs a Tensor that holds the new value of `ref` after\n the value has been assigned. This makes it easier to chain operations that\n need to use the reset value.\n\n Args:\n ref: A mutable `Tensor`. Should be from a `Variable` node. May be\n uninitialized.\n value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to\n be assigned to the variable.\n validate_shape: An optional `bool`. Defaults to `True`. If true, the\n operation will validate that the shape of 'value' matches the shape of the\n Tensor being assigned to. If false, 'ref' will take on the shape of\n 'value'.\n use_locking: An optional `bool`. Defaults to `True`. If True, the assignment\n will be protected by a lock; otherwise the behavior is undefined, but may\n exhibit less contention.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that will hold the new value of `ref` after\n the assignment has completed.\n\n @compatibility(TF2)\n `tf.compat.v1.assign` is mostly compatible with eager\n execution and `tf.function`. However, argument 'validate_shape' will be\n ignored. To avoid shape validation, set 'shape' to tf.TensorShape(None) when\n constructing the variable:\n\n >>> import tensorflow as tf\n >>> a = tf.Variable([1], shape=tf.TensorShape(None))\n >>> tf.compat.v1.assign(a, [2,3])\n\n To switch to the native TF2 style, one could use method 'assign' of\n `tf.Variable`:\n\n #### How to Map Arguments\n\n | TF1 Arg Name | TF2 Arg Name | Note |\n | :-------------------- | :-------------- | :------------------------- |\n | `ref` | `self` | In `assign()` method |\n | `value` | `value` | In `assign()` method |\n | `validate_shape` | Not supported | Specify `shape` in the |\n : : : constructor to replicate :\n : : : behavior :\n | `use_locking` | `use_locking` | In `assign()` method |\n | `name` | `name` | In `assign()` method |\n | - | `read_value` | Set to True to replicate |\n : : : behavior (True is default) :\n @end_compatibility\n\n\n #### Before & After Usage Example\n\n Before:\n\n >>> with tf.Graph().as_default():\n ... with tf.compat.v1.Session() as sess:\n ... a = tf.compat.v1.Variable(0, dtype=tf.int64)\n ... sess.run(a.initializer)\n ... update_op = tf.compat.v1.assign(a, 2)\n ... res_a = sess.run(update_op)\n ... res_a\n 2\n\n After:\n\n >>> b = tf.Variable(0, dtype=tf.int64)\n >>> res_b = b.assign(2)\n >>> res_b.numpy()\n 2\n ", "desc": "Update `ref` by assigning `value` to it.", "type": "API"}, {"name": "tf.compat.v1.assign_add", "docs": "Update `ref` by adding `value` to it.\n\n This operation outputs `ref` after the update is done.\n This makes it easier to chain operations that need to use the reset value.\n Unlike `tf.math.add`, this op does not broadcast. `ref` and `value` must have\n the same shape.\n\n Args:\n ref: A mutable `Tensor`. Must be one of the following types: `float32`,\n `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`,\n `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. Should be\n from a `Variable` node.\n value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to\n be added to the variable.\n use_locking: An optional `bool`. Defaults to `False`. If True, the addition\n will be protected by a lock; otherwise the behavior is undefined, but may\n exhibit less contention.\n name: A name for the operation (optional).\n\n Returns:\n Same as `ref`. Returned as a convenience for operations that want\n to use the new value after the variable has been updated.\n\n @compatibility(TF2)\n `tf.compat.v1.assign_add` is mostly compatible with eager\n execution and `tf.function`.\n\n To switch to the native TF2 style, one could use method 'assign_add' of\n `tf.Variable`:\n\n #### How to Map Arguments\n\n | TF1 Arg Name | TF2 Arg Name | Note |\n | :-------------------- | :-------------- | :------------------------- |\n | `ref` | `self` | In `assign_add()` method |\n | `value` | `value` | In `assign_add()` method |\n | `use_locking` | `use_locking` | In `assign_add()` method |\n | `name` | `name` | In `assign_add()` method |\n | - | `read_value` | Set to True to replicate |\n : : : behavior (True is default) :\n\n\n #### Before & After Usage Example\n\n Before:\n\n >>> with tf.Graph().as_default():\n ... with tf.compat.v1.Session() as sess:\n ... a = tf.compat.v1.Variable(0, dtype=tf.int64)\n ... sess.run(a.initializer)\n ... update_op = tf.compat.v1.assign_add(a, 1)\n ... res_a = sess.run(update_op)\n ... res_a\n 1\n\n After:\n\n >>> b = tf.Variable(0, dtype=tf.int64)\n >>> res_b = b.assign_add(1)\n >>> res_b.numpy()\n 1\n\n @end_compatibility\n ", "desc": "Update `ref` by adding `value` to it.", "type": "API"}, {"name": "tf.compat.v1.assign_sub", "docs": "Update `ref` by subtracting `value` from it.\n\n This operation outputs `ref` after the update is done.\n This makes it easier to chain operations that need to use the reset value.\n Unlike `tf.math.subtract`, this op does not broadcast. `ref` and `value`\n must have the same shape.\n\n Args:\n ref: A mutable `Tensor`. Must be one of the following types: `float32`,\n `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`,\n `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. Should be\n from a `Variable` node.\n value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to\n be subtracted to the variable.\n use_locking: An optional `bool`. Defaults to `False`. If True, the\n subtraction will be protected by a lock; otherwise the behavior is\n undefined, but may exhibit less contention.\n name: A name for the operation (optional).\n\n Returns:\n Same as `ref`. Returned as a convenience for operations that want\n to use the new value after the variable has been updated.\n\n @compatibility(TF2)\n `tf.compat.v1.assign_sub` is mostly compatible with eager\n execution and `tf.function`.\n\n To switch to the native TF2 style, one could use method 'assign_sub' of\n `tf.Variable`:\n\n #### How to Map Arguments\n\n | TF1 Arg Name | TF2 Arg Name | Note |\n | :-------------------- | :-------------- | :------------------------- |\n | `ref` | `self` | In `assign_sub()` method |\n | `value` | `value` | In `assign_sub()` method |\n | `use_locking` | `use_locking` | In `assign_sub()` method |\n | `name` | `name` | In `assign_sub()` method |\n | - | `read_value` | Set to True to replicate |\n : : : behavior (True is default) :\n\n\n #### Before & After Usage Example\n\n Before:\n\n >>> with tf.Graph().as_default():\n ... with tf.compat.v1.Session() as sess:\n ... a = tf.compat.v1.Variable(1, dtype=tf.int64)\n ... sess.run(a.initializer)\n ... update_op = tf.compat.v1.assign_sub(a, 1)\n ... res_a = sess.run(update_op)\n ... res_a\n 0\n\n After:\n\n >>> b = tf.Variable(1, dtype=tf.int64)\n >>> res_b = b.assign_sub(1)\n >>> res_b.numpy()\n 0\n\n @end_compatibility\n ", "desc": "Update `ref` by subtracting `value` from it.", "type": "API"}, {"name": "tf.compat.v1.atan", "docs": "Computes the trignometric inverse tangent of x element-wise.\n\n The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that\n if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.\n\n **Note**: The output of `tf.math.atan` will lie within the invertible range\n of tan, i.e (-pi/2, pi/2).\n\n For example:\n\n ```python\n # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]\n x = tf.constant([1.047, 0.785])\n y = tf.math.tan(x) # [1.731261, 0.99920404]\n\n tf.math.atan(y) # [1.047, 0.785] = x\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes the trignometric inverse tangent of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.atan2", "docs": "Computes arctangent of `y/x` element-wise, respecting signs of the arguments.\n\n This is the angle \\\\( \\theta \\in [-\\pi, \\pi] \\\\) such that\n \\\\[ x = r \\cos(\\theta) \\\\]\n and\n \\\\[ y = r \\sin(\\theta) \\\\]\n where \\\\(r = \\sqrt{x^2 + y^2} \\\\).\n\n For example:\n\n >>> x = [1., 1.]\n >>> y = [1., -1.]\n >>> print((tf.math.atan2(y,x) * (180 / np.pi)).numpy())\n [ 45. -45.]\n\n Args:\n y: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n x: A `Tensor`. Must have the same type as `y`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `y`.\n ", "desc": "Computes arctangent of `y/x` element-wise, respecting signs of the arguments.", "type": "API"}, {"name": "tf.compat.v1.atanh", "docs": "Computes inverse hyperbolic tangent of x element-wise.\n\n Given an input tensor, this function computes inverse hyperbolic tangent\n for every element in the tensor. Input range is `[-1,1]` and output range is\n `[-inf, inf]`. If input is `-1`, output will be `-inf` and if the\n input is `1`, output will be `inf`. Values outside the range will have\n `nan` as output.\n\n ```python\n x = tf.constant([-float(\"inf\"), -1, -0.5, 1, 0, 0.5, 10, float(\"inf\")])\n tf.math.atanh(x) ==> [nan -inf -0.54930615 inf 0. 0.54930615 nan nan]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes inverse hyperbolic tangent of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.AttrValue", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.AttrValue.ListValue", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.audio", "docs": "Public API for tf.audio namespace.\n", "desc": "Public API for tf.audio namespace.", "type": "API"}, {"name": "tf.compat.v1.audio.decode_wav", "docs": "Decode a 16-bit PCM WAV file to a float tensor.\n\n The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.\n\n When desired_channels is set, if the input contains fewer channels than this\n then the last channel will be duplicated to give the requested number, else if\n the input has more channels than requested then the additional channels will be\n ignored.\n\n If desired_samples is set, then the audio will be cropped or padded with zeroes\n to the requested length.\n\n The first output contains a Tensor with the content of the audio samples. The\n lowest dimension will be the number of channels, and the second will be the\n number of samples. For example, a ten-sample-long stereo WAV file should give an\n output shape of [10, 2].\n\n Args:\n contents: A `Tensor` of type `string`.\n The WAV-encoded audio, usually from a file.\n desired_channels: An optional `int`. Defaults to `-1`.\n Number of sample channels wanted.\n desired_samples: An optional `int`. Defaults to `-1`.\n Length of audio requested.\n name: A name for the operation (optional).\n\n Returns:\n A tuple of `Tensor` objects (audio, sample_rate).\n\n audio: A `Tensor` of type `float32`.\n sample_rate: A `Tensor` of type `int32`.\n ", "desc": "Decode a 16-bit PCM WAV file to a float tensor.", "type": "API"}, {"name": "tf.compat.v1.audio.encode_wav", "docs": "Encode audio data using the WAV file format.\n\n This operation will generate a string suitable to be saved out to create a .wav\n audio file. It will be encoded in the 16-bit PCM format. It takes in float\n values in the range -1.0f to 1.0f, and any outside that value will be clamped to\n that range.\n\n `audio` is a 2-D float Tensor of shape `[length, channels]`.\n `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).\n\n Args:\n audio: A `Tensor` of type `float32`. 2-D with shape `[length, channels]`.\n sample_rate: A `Tensor` of type `int32`.\n Scalar containing the sample frequency.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Encode audio data using the WAV file format.", "type": "API"}, {"name": "tf.compat.v1.autograph", "docs": "Conversion of eager-style Python into TensorFlow graph code.\n\nNOTE: In TensorFlow 2.0, AutoGraph is automatically applied when using\n`tf.function`. This module contains lower-level APIs for advanced use.\n\nAutoGraph transforms a subset of Python which operates on TensorFlow objects\ninto equivalent TensorFlow graph code. When executing the graph, it has the same\neffect as if you ran the original code in eager mode.\nPython code which doesn't operate on TensorFlow objects remains functionally\nunchanged, but keep in mind that `tf.function` only executes such code at trace\ntime, and generally will not be consistent with eager execution.\n\nFor more information, see the\n[AutoGraph reference documentation](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/index.md),\nand the [tf.function guide](https://www.tensorflow.org/guide/function#autograph_transformations).\n\n", "desc": "Conversion of eager-style Python into TensorFlow graph code.", "type": "API"}, {"name": "tf.compat.v1.autograph.experimental", "docs": "Public API for tf.autograph.experimental namespace.\n", "desc": "Public API for tf.autograph.experimental namespace.", "type": "API"}, {"name": "tf.compat.v1.autograph.experimental.do_not_convert", "docs": "Decorator that suppresses the conversion of a function.\n\n Args:\n func: function to decorate.\n\n Returns:\n If `func` is not None, returns a `Callable` which is equivalent to\n `func`, but is not converted by AutoGraph.\n If `func` is None, returns a decorator that, when invoked with a\n single `func` argument, returns a `Callable` equivalent to the\n above case.\n ", "desc": "Decorator that suppresses the conversion of a function.", "type": "API"}, {"name": "tf.compat.v1.autograph.experimental.Feature", "docs": "This enumeration represents optional conversion options.\n\n These conversion options are experimental. They are subject to change without\n notice and offer no guarantees.\n\n _Example Usage_\n\n ```python\n optionals= tf.autograph.experimental.Feature.EQUALITY_OPERATORS\n @tf.function(experimental_autograph_options=optionals)\n def f(i):\n if i == 0: # EQUALITY_OPERATORS allows the use of == here.\n tf.print('i is zero')\n ```\n\n Attributes:\n ALL: Enable all features.\n AUTO_CONTROL_DEPS: Insert of control dependencies in the generated code.\n ASSERT_STATEMENTS: Convert Tensor-dependent assert statements to tf.Assert.\n BUILTIN_FUNCTIONS: Convert builtin functions applied to Tensors to\n their TF counterparts.\n EQUALITY_OPERATORS: Whether to convert the comparison operators, like\n equality. This is soon to be deprecated as support is being added to the\n Tensor class.\n LISTS: Convert list idioms, like initializers, slices, append, etc.\n NAME_SCOPES: Insert name scopes that name ops according to context, like the\n function they were defined in.\n ", "desc": "This enumeration represents optional conversion options.", "type": "API"}, {"name": "tf.compat.v1.autograph.experimental.set_loop_options", "docs": "Specifies additional arguments to be passed to the enclosing while_loop.\n\n The parameters apply to and only to the immediately enclosing loop. It only\n has effect if the loop is staged as a TF while_loop; otherwise the parameters\n have no effect.\n\n Usage:\n\n >>> @tf.function(autograph=True)\n ... def f():\n ... n = 0\n ... for i in tf.range(10):\n ... tf.autograph.experimental.set_loop_options(maximum_iterations=3)\n ... n += 1\n ... return n\n\n >>> @tf.function(autograph=True)\n ... def f():\n ... v = tf.constant((0,))\n ... for i in tf.range(3):\n ... tf.autograph.experimental.set_loop_options(\n ... shape_invariants=[(v, tf.TensorShape([None]))]\n ... )\n ... v = tf.concat((v, [i]), 0)\n ... return v\n\n Also see tf.while_loop.\n\n Args:\n parallel_iterations: The maximum number of iterations allowed to run in\n parallel at any given time. Note that this does not guarantee parallel\n execution.\n swap_memory: Whether to store intermediate values needed for\n gradients on the CPU instead of GPU.\n maximum_iterations: Allows limiting the total number of iterations executed\n by the loop.\n shape_invariants: Allows controlling the argument with the same name passed\n to tf.while_loop. Unlike tf.while_loop, this is a list of\n `(tensor, shape)` pairs.\n ", "desc": "Specifies additional arguments to be passed to the enclosing while_loop.", "type": "API"}, {"name": "tf.compat.v1.autograph.set_verbosity", "docs": "Sets the AutoGraph verbosity level.\n\n _Debug logging in AutoGraph_\n\n More verbose logging is useful to enable when filing bug reports or doing\n more in-depth debugging.\n\n There are two means to control the logging verbosity:\n\n * The `set_verbosity` function\n\n * The `AUTOGRAPH_VERBOSITY` environment variable\n\n `set_verbosity` takes precedence over the environment variable.\n\n For example:\n\n ```python\n import os\n import tensorflow as tf\n\n os.environ['AUTOGRAPH_VERBOSITY'] = '5'\n # Verbosity is now 5\n\n tf.autograph.set_verbosity(0)\n # Verbosity is now 0\n\n os.environ['AUTOGRAPH_VERBOSITY'] = '1'\n # No effect, because set_verbosity was already called.\n ```\n\n Logs entries are output to [absl](https://abseil.io)'s\n [default output](https://abseil.io/docs/python/guides/logging),\n with `INFO` level.\n Logs can be mirrored to stdout by using the `alsologtostdout` argument.\n Mirroring is enabled by default when Python runs in interactive mode.\n\n Args:\n level: int, the verbosity level; larger values specify increased verbosity;\n 0 means no logging. When reporting bugs, it is recommended to set this\n value to a larger number, like 10.\n alsologtostdout: bool, whether to also output log messages to `sys.stdout`.\n ", "desc": "Sets the AutoGraph verbosity level.", "type": "API"}, {"name": "tf.compat.v1.autograph.to_code", "docs": "Returns the source code generated by AutoGraph, as a string.\n\n Example usage:\n\n >>> def f(x):\n ... if x < 0:\n ... x = -x\n ... return x\n >>> tf.autograph.to_code(f)\n \"...def tf__f(x):...\"\n\n Also see: `tf.autograph.to_graph`.\n\n Note: If a function has been decorated with `tf.function`, pass its\n underlying Python function, rather than the callable that `tf.function\n creates:\n\n >>> @tf.function\n ... def f(x):\n ... if x < 0:\n ... x = -x\n ... return x\n >>> tf.autograph.to_code(f.python_function)\n \"...def tf__f(x):...\"\n\n Args:\n entity: Python callable or class.\n recursive: Whether to recursively convert any functions that the converted\n function may call.\n arg_values: Deprecated.\n arg_types: Deprecated.\n indentation: Deprecated.\n experimental_optional_features: `None`, a tuple of, or a single\n `tf.autograph.experimental.Feature` value.\n\n Returns:\n The converted code as string.\n ", "desc": "Returns the source code generated by AutoGraph, as a string.", "type": "API"}, {"name": "tf.compat.v1.autograph.to_graph", "docs": "Converts a Python entity into a TensorFlow graph.\n\n Also see: `tf.autograph.to_code`, `tf.function`.\n\n Unlike `tf.function`, `to_graph` is a low-level transpiler that converts\n Python code to TensorFlow graph code. It does not implement any caching,\n variable management or create any actual ops, and is best used where greater\n control over the generated TensorFlow graph is desired. Another difference\n from `tf.function` is that `to_graph` will not wrap the graph into a\n TensorFlow function or a Python callable. Internally, `tf.function` uses\n `to_graph`.\n\n _Example Usage_\n\n ```python\n def foo(x):\n if x > 0:\n y = x * x\n else:\n y = -x\n return y\n\n converted_foo = to_graph(foo)\n\n x = tf.constant(1)\n y = converted_foo(x) # converted_foo is a TensorFlow Op-like.\n assert is_tensor(y)\n ```\n\n Supported Python entities include:\n * functions\n * classes\n * object methods\n\n Functions are converted into new functions with converted code.\n\n Classes are converted by generating a new class whose methods use converted\n code.\n\n Methods are converted into unbound function that have an additional first\n argument called `self`.\n\n Args:\n entity: Python callable or class to convert.\n recursive: Whether to recursively convert any functions that the converted\n function may call.\n arg_values: Deprecated.\n arg_types: Deprecated.\n experimental_optional_features: `None`, a tuple of, or a single\n `tf.autograph.experimental.Feature` value.\n\n Returns:\n Same as `entity`, the converted Python function or class.\n\n Raises:\n ValueError: If the entity could not be converted.\n ", "desc": "Converts a Python entity into a TensorFlow graph.", "type": "API"}, {"name": "tf.compat.v1.autograph.trace", "docs": "Traces argument information at compilation time.\n\n `trace` is useful when debugging, and it always executes during the tracing\n phase, that is, when the TF graph is constructed.\n\n _Example usage_\n\n ```python\n import tensorflow as tf\n\n for i in tf.range(10):\n tf.autograph.trace(i)\n # Output: \n ```\n\n Args:\n *args: Arguments to print to `sys.stdout`.\n ", "desc": "Traces argument information at compilation time.", "type": "API"}, {"name": "tf.compat.v1.batch_gather", "docs": "Gather slices from params according to indices with leading batch dims. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed after 2017-10-25.\nInstructions for updating:\n`tf.batch_gather` is deprecated, please use `tf.gather` with `batch_dims=tf.rank(indices) - 1` instead.", "desc": "Gather slices from params according to indices with leading batch dims. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.batch_scatter_update", "docs": "Generalization of `tf.compat.v1.scatter_update` to axis different than 0. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed after 2018-11-29.\nInstructions for updating:\nUse the batch_scatter_update method of Variable instead.\n\nAnalogous to `batch_gather`. This assumes that `ref`, `indices` and `updates`\nhave a series of leading dimensions that are the same for all of them, and the\nupdates are performed on the last dimension of indices. In other words, the\ndimensions should be the following:\n\n`num_prefix_dims = indices.ndims - 1`\n`batch_dim = num_prefix_dims + 1`\n`updates.shape = indices.shape + var.shape[batch_dim:]`\n\nwhere\n\n`updates.shape[:num_prefix_dims]`\n`== indices.shape[:num_prefix_dims]`\n`== var.shape[:num_prefix_dims]`\n\nAnd the operation performed can be expressed as:\n\n`var[i_1, ..., i_n, indices[i_1, ..., i_n, j]] = updates[i_1, ..., i_n, j]`\n\nWhen indices is a 1D tensor, this operation is equivalent to\n`tf.compat.v1.scatter_update`.\n\nTo avoid this operation there would be 2 alternatives:\n1) Reshaping the variable by merging the first `ndims` dimensions. However,\n this is not possible because `tf.reshape` returns a Tensor, which we\n cannot use `tf.compat.v1.scatter_update` on.\n2) Looping over the first `ndims` of the variable and using\n `tf.compat.v1.scatter_update` on the subtensors that result of slicing the\n first\n dimension. This is a valid option for `ndims = 1`, but less efficient than\n this implementation.\n\nSee also `tf.compat.v1.scatter_update` and `tf.compat.v1.scatter_nd_update`.\n\nArgs:\n ref: `Variable` to scatter onto.\n indices: Tensor containing indices as described above.\n updates: Tensor of updates to apply to `ref`.\n use_locking: Boolean indicating whether to lock the writing operation.\n name: Optional scope name string.\n\nReturns:\n Ref to `variable` after it has been modified.\n\nRaises:\n ValueError: If the initial `ndims` of `ref`, `indices`, and `updates` are\n not the same.", "desc": "Generalization of `tf.compat.v1.scatter_update` to axis different than 0. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.batch_to_space", "docs": "BatchToSpace for 4-D tensors of type T.\n\n This is a legacy version of the more general BatchToSpaceND.\n\n Rearranges (permutes) data from batch into blocks of spatial data, followed by\n cropping. This is the reverse transformation of SpaceToBatch. More specifically,\n this op outputs a copy of the input tensor where values from the `batch`\n dimension are moved in spatial blocks to the `height` and `width` dimensions,\n followed by cropping along the `height` and `width` dimensions.\n\n Args:\n input: A `Tensor`. 4-D tensor with shape\n `[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,\n depth]`. Note that the batch size of the input tensor must be divisible by\n `block_size * block_size`.\n crops: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies\n how many elements to crop from the intermediate result across the spatial\n dimensions as follows:\n\n crops = [[crop_top, crop_bottom], [crop_left, crop_right]]\n block_size: An `int` that is `>= 2`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "BatchToSpace for 4-D tensors of type T.", "type": "API"}, {"name": "tf.compat.v1.batch_to_space_nd", "docs": "BatchToSpace for N-D tensors of type T.\n\n This operation reshapes the \"batch\" dimension 0 into `M + 1` dimensions of shape\n `block_shape + [batch]`, interleaves these blocks back into the grid defined by\n the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as\n the input. The spatial dimensions of this intermediate result are then\n optionally cropped according to `crops` to produce the output. This is the\n reverse of SpaceToBatch. See below for a precise description.\n\n Args:\n input: A `Tensor`.\n N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,\n where spatial_shape has M dimensions.\n block_shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n 1-D with shape `[M]`, all values must be >= 1.\n crops: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n 2-D with shape `[M, 2]`, all values must be >= 0.\n `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input\n dimension `i + 1`, which corresponds to spatial dimension `i`. It is\n required that\n `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.\n\n This operation is equivalent to the following steps:\n\n 1. Reshape `input` to `reshaped` of shape:\n [block_shape[0], ..., block_shape[M-1],\n batch / prod(block_shape),\n input_shape[1], ..., input_shape[N-1]]\n\n 2. Permute dimensions of `reshaped` to produce `permuted` of shape\n [batch / prod(block_shape),\n\n input_shape[1], block_shape[0],\n ...,\n input_shape[M], block_shape[M-1],\n\n input_shape[M+1], ..., input_shape[N-1]]\n\n 3. Reshape `permuted` to produce `reshaped_permuted` of shape\n [batch / prod(block_shape),\n\n input_shape[1] * block_shape[0],\n ...,\n input_shape[M] * block_shape[M-1],\n\n input_shape[M+1],\n ...,\n input_shape[N-1]]\n\n 4. Crop the start and end of dimensions `[1, ..., M]` of\n `reshaped_permuted` according to `crops` to produce the output of shape:\n [batch / prod(block_shape),\n\n input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],\n ...,\n input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],\n\n input_shape[M+1], ..., input_shape[N-1]]\n\n Some examples:\n\n (1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and\n `crops = [[0, 0], [0, 0]]`:\n\n ```\n [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]\n ```\n\n The output tensor has shape `[1, 2, 2, 1]` and value:\n\n ```\n x = [[[[1], [2]], [[3], [4]]]]\n ```\n\n (2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and\n `crops = [[0, 0], [0, 0]]`:\n\n ```\n [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]\n ```\n\n The output tensor has shape `[1, 2, 2, 3]` and value:\n\n ```\n x = [[[[1, 2, 3], [4, 5, 6]],\n [[7, 8, 9], [10, 11, 12]]]]\n ```\n\n (3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and\n `crops = [[0, 0], [0, 0]]`:\n\n ```\n x = [[[[1], [3]], [[9], [11]]],\n [[[2], [4]], [[10], [12]]],\n [[[5], [7]], [[13], [15]]],\n [[[6], [8]], [[14], [16]]]]\n ```\n\n The output tensor has shape `[1, 4, 4, 1]` and value:\n\n ```\n x = [[[[1], [2], [3], [4]],\n [[5], [6], [7], [8]],\n [[9], [10], [11], [12]],\n [[13], [14], [15], [16]]]]\n ```\n\n (4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and\n `crops = [[0, 0], [2, 0]]`:\n\n ```\n x = [[[[0], [1], [3]]], [[[0], [9], [11]]],\n [[[0], [2], [4]]], [[[0], [10], [12]]],\n [[[0], [5], [7]]], [[[0], [13], [15]]],\n [[[0], [6], [8]]], [[[0], [14], [16]]]]\n ```\n\n The output tensor has shape `[2, 2, 4, 1]` and value:\n\n ```\n x = [[[[1], [2], [3], [4]],\n [[5], [6], [7], [8]]],\n [[[9], [10], [11], [12]],\n [[13], [14], [15], [16]]]]\n ```\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "BatchToSpace for N-D tensors of type T.", "type": "API"}, {"name": "tf.compat.v1.betainc", "docs": "Compute the regularized incomplete beta integral \\\\(I_x(a, b)\\\\).\n\n The regularized incomplete beta integral is defined as:\n\n\n \\\\(I_x(a, b) = \\frac{B(x; a, b)}{B(a, b)}\\\\)\n\n where\n\n\n \\\\(B(x; a, b) = \\int_0^x t^{a-1} (1 - t)^{b-1} dt\\\\)\n\n\n is the incomplete beta function and \\\\(B(a, b)\\\\) is the *complete*\n beta function.\n\n Args:\n a: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n b: A `Tensor`. Must have the same type as `a`.\n x: A `Tensor`. Must have the same type as `a`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `a`.\n ", "desc": "Compute the regularized incomplete beta integral \\\\(I_x(a, b)\\\\).", "type": "API"}, {"name": "tf.compat.v1.bincount", "docs": "Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n ", "desc": "Counts the number of occurrences of each value in an integer array.", "type": "API"}, {"name": "tf.compat.v1.bitcast", "docs": "Bitcasts a tensor from one type to another without copying data.\n\n Given a tensor `input`, this operation returns a tensor that has the same buffer\n data as `input` with datatype `type`.\n\n If the input datatype `T` is larger than the output datatype `type` then the\n shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].\n\n If `T` is smaller than `type`, the operator requires that the rightmost\n dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from\n [..., sizeof(`type`)/sizeof(`T`)] to [...].\n\n tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype\n (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast()\n gives module error.\n For example,\n\n Example 1:\n\n >>> a = [1., 2., 3.]\n >>> equality_bitcast = tf.bitcast(a, tf.complex128)\n Traceback (most recent call last):\n ...\n InvalidArgumentError: Cannot bitcast from 1 to 18 [Op:Bitcast]\n >>> equality_cast = tf.cast(a, tf.complex128)\n >>> print(equality_cast)\n tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128)\n\n Example 2:\n\n >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)\n \n\n Example 3:\n\n >>> x = [1., 2., 3.]\n >>> y = [0., 2., 3.]\n >>> equality= tf.equal(x,y)\n >>> equality_cast = tf.cast(equality,tf.float32)\n >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8)\n >>> print(equality)\n tf.Tensor([False True True], shape=(3,), dtype=bool)\n >>> print(equality_cast)\n tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32)\n >>> print(equality_bitcast)\n tf.Tensor(\n [[ 0 0 0 0]\n [ 0 0 128 63]\n [ 0 0 128 63]], shape=(3, 4), dtype=uint8)\n\n *NOTE*: Bitcast is implemented as a low-level cast, so machines with different\n endian orderings will give different results.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `complex64`, `complex128`, `qint8`, `quint8`, `qint16`, `quint16`, `qint32`.\n type: A `tf.DType` from: `tf.bfloat16, tf.half, tf.float32, tf.float64, tf.int64, tf.int32, tf.uint8, tf.uint16, tf.uint32, tf.uint64, tf.int8, tf.int16, tf.complex64, tf.complex128, tf.qint8, tf.quint8, tf.qint16, tf.quint16, tf.qint32`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `type`.\n ", "desc": "Bitcasts a tensor from one type to another without copying data.", "type": "API"}, {"name": "tf.compat.v1.bitwise", "docs": "Operations for manipulating the binary representations of integers.\n", "desc": "Operations for manipulating the binary representations of integers.", "type": "API"}, {"name": "tf.compat.v1.bitwise.bitwise_and", "docs": "Elementwise computes the bitwise AND of `x` and `y`.\n\n The result will have those bits set, that are set in both `x` and `y`. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_and(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise AND of `x` and `y`.", "type": "API"}, {"name": "tf.compat.v1.bitwise.bitwise_or", "docs": "Elementwise computes the bitwise OR of `x` and `y`.\n\n The result will have those bits set, that are set in `x`, `y` or both. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_or(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise OR of `x` and `y`.", "type": "API"}, {"name": "tf.compat.v1.bitwise.bitwise_xor", "docs": "Elementwise computes the bitwise XOR of `x` and `y`.\n\n The result will have those bits set, that are different in `x` and `y`. The\n computation is performed on the underlying representations of `x` and `y`.\n\n For example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,\n tf.uint8, tf.uint16, tf.uint32, tf.uint64]\n\n for dtype in dtype_list:\n lhs = tf.constant([0, 5, 3, 14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n exp = tf.constant([5, 5, 4, 5], dtype=tf.float32)\n\n res = bitwise_ops.bitwise_xor(lhs, rhs)\n tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise XOR of `x` and `y`.", "type": "API"}, {"name": "tf.compat.v1.bitwise.invert", "docs": "Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.\n\n Flip each bit of supported types. For example, type `int8` (decimal 2) binary 00000010 becomes (decimal -3) binary 11111101.\n This operation is performed on each element of the tensor argument `x`.\n\n Example:\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n\n # flip 2 (00000010) to -3 (11111101)\n tf.assert_equal(-3, bitwise_ops.invert(2))\n\n dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64,\n dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]\n\n inputs = [0, 5, 3, 14]\n for dtype in dtype_list:\n # Because of issues with negative numbers, let's test this indirectly.\n # 1. invert(a) and a = 0\n # 2. invert(a) or a = invert(0)\n input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype)\n not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and(\n input_tensor, bitwise_ops.invert(input_tensor)),\n bitwise_ops.bitwise_or(\n input_tensor, bitwise_ops.invert(input_tensor)),\n bitwise_ops.invert(\n tf.constant(0, dtype=dtype))]\n\n expected = tf.constant([0, 0, 0, 0], dtype=tf.float32)\n tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)\n\n expected = tf.cast([not_0] * 4, tf.float32)\n tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)\n\n # For unsigned dtypes let's also check the result directly.\n if dtype.is_unsigned:\n inverted = bitwise_ops.invert(input_tensor)\n expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32)\n tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.", "type": "API"}, {"name": "tf.compat.v1.bitwise.left_shift", "docs": "Elementwise computes the bitwise left-shift of `x` and `y`.\n\n If `y` is negative, or greater than or equal to the width of `x` in bits the\n result is implementation defined.\n\n Example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n import numpy as np\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]\n\n for dtype in dtype_list:\n lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n\n left_shift_result = bitwise_ops.left_shift(lhs, rhs)\n\n print(left_shift_result)\n\n # This will print:\n # tf.Tensor([ -32 -5 -128 0], shape=(4,), dtype=int8)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int16)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int32)\n # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int64)\n\n lhs = np.array([-2, 64, 101, 32], dtype=np.int8)\n rhs = np.array([-1, -5, -3, -14], dtype=np.int8)\n bitwise_ops.left_shift(lhs, rhs)\n # \n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise left-shift of `x` and `y`.", "type": "API"}, {"name": "tf.compat.v1.bitwise.right_shift", "docs": "Elementwise computes the bitwise right-shift of `x` and `y`.\n\n Performs a logical shift for unsigned integer types, and an arithmetic shift\n for signed integer types.\n\n If `y` is negative, or greater than or equal to than the width of `x` in bits\n the result is implementation defined.\n\n Example:\n\n ```python\n import tensorflow as tf\n from tensorflow.python.ops import bitwise_ops\n import numpy as np\n dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]\n\n for dtype in dtype_list:\n lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)\n rhs = tf.constant([5, 0, 7, 11], dtype=dtype)\n\n right_shift_result = bitwise_ops.right_shift(lhs, rhs)\n\n print(right_shift_result)\n\n # This will print:\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32)\n # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)\n\n lhs = np.array([-2, 64, 101, 32], dtype=np.int8)\n rhs = np.array([-1, -5, -3, -14], dtype=np.int8)\n bitwise_ops.right_shift(lhs, rhs)\n # \n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.\n y: A `Tensor`. Must have the same type as `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Elementwise computes the bitwise right-shift of `x` and `y`.", "type": "API"}, {"name": "tf.compat.v1.boolean_mask", "docs": "Apply boolean mask to tensor.\n\n Numpy equivalent is `tensor[mask]`.\n\n In general, `0 < dim(mask) = K <= dim(tensor)`, and `mask`'s shape must match\n the first K dimensions of `tensor`'s shape. We then have:\n `boolean_mask(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd]`\n where `(i1,...,iK)` is the ith `True` entry of `mask` (row-major order).\n The `axis` could be used with `mask` to indicate the axis to mask from.\n In that case, `axis + dim(mask) <= dim(tensor)` and `mask`'s shape must match\n the first `axis + dim(mask)` dimensions of `tensor`'s shape.\n\n See also: `tf.ragged.boolean_mask`, which can be applied to both dense and\n ragged tensors, and can be used if you need to preserve the masked dimensions\n of `tensor` (rather than flattening them, as `tf.boolean_mask` does).\n\n Examples:\n\n ```python\n # 1-D example\n tensor = [0, 1, 2, 3]\n mask = np.array([True, False, True, False])\n tf.boolean_mask(tensor, mask) # [0, 2]\n\n # 2-D example\n tensor = [[1, 2], [3, 4], [5, 6]]\n mask = np.array([True, False, True])\n tf.boolean_mask(tensor, mask) # [[1, 2], [5, 6]]\n ```\n\n Args:\n tensor: N-D Tensor.\n mask: K-D boolean Tensor, K <= N and K must be known statically.\n name: A name for this operation (optional).\n axis: A 0-D int Tensor representing the axis in `tensor` to mask from. By\n default, axis is 0 which will mask from the first dimension. Otherwise K +\n axis <= N.\n\n Returns:\n (N-K+1)-dimensional tensor populated by entries in `tensor` corresponding\n to `True` values in `mask`.\n\n Raises:\n ValueError: If shapes do not conform.\n ", "desc": "Apply boolean mask to tensor.", "type": "API"}, {"name": "tf.compat.v1.broadcast_dynamic_shape", "docs": "Computes the shape of a broadcast given symbolic shapes.\n\n When `shape_x` and `shape_y` are Tensors representing shapes (i.e. the result\n of calling tf.shape on another Tensor) this computes a Tensor which is the\n shape of the result of a broadcasting op applied in tensors of shapes\n `shape_x` and `shape_y`.\n\n This is useful when validating the result of a broadcasting operation when the\n tensors do not have statically known shapes.\n\n Example:\n\n >>> shape_x = (1, 2, 3)\n >>> shape_y = (5, 1, 3)\n >>> tf.broadcast_dynamic_shape(shape_x, shape_y)\n \n\n Args:\n shape_x: A rank 1 integer `Tensor`, representing the shape of x.\n shape_y: A rank 1 integer `Tensor`, representing the shape of y.\n\n Returns:\n A rank 1 integer `Tensor` representing the broadcasted shape.\n\n Raises:\n InvalidArgumentError: If the two shapes are incompatible for\n broadcasting.\n ", "desc": "Computes the shape of a broadcast given symbolic shapes.", "type": "API"}, {"name": "tf.compat.v1.broadcast_static_shape", "docs": "Computes the shape of a broadcast given known shapes.\n\n When `shape_x` and `shape_y` are fully known `TensorShape`s this computes a\n `TensorShape` which is the shape of the result of a broadcasting op applied in\n tensors of shapes `shape_x` and `shape_y`.\n\n For example, if shape_x is `TensorShape([1, 2, 3])` and shape_y is\n `TensorShape([5, 1, 3])`, the result is a TensorShape whose value is\n `TensorShape([5, 2, 3])`.\n\n This is useful when validating the result of a broadcasting operation when the\n tensors have statically known shapes.\n\n Example:\n\n >>> shape_x = tf.TensorShape([1, 2, 3])\n >>> shape_y = tf.TensorShape([5, 1 ,3])\n >>> tf.broadcast_static_shape(shape_x, shape_y)\n TensorShape([5, 2, 3])\n\n Args:\n shape_x: A `TensorShape`\n shape_y: A `TensorShape`\n\n Returns:\n A `TensorShape` representing the broadcasted shape.\n\n Raises:\n ValueError: If the two shapes can not be broadcasted.\n ", "desc": "Computes the shape of a broadcast given known shapes.", "type": "API"}, {"name": "tf.compat.v1.broadcast_to", "docs": "Broadcast an array for a compatible shape.\n\n Broadcasting is the process of making arrays to have compatible shapes\n for arithmetic operations. Two shapes are compatible if for each\n dimension pair they are either equal or one of them is one. When trying\n to broadcast a Tensor to a shape, it starts with the trailing dimensions,\n and works its way forward.\n\n For example,\n\n >>> x = tf.constant([1, 2, 3])\n >>> y = tf.broadcast_to(x, [3, 3])\n >>> print(y)\n tf.Tensor(\n [[1 2 3]\n [1 2 3]\n [1 2 3]], shape=(3, 3), dtype=int32)\n\n In the above example, the input Tensor with the shape of `[1, 3]`\n is broadcasted to output Tensor with shape of `[3, 3]`.\n\n When doing broadcasted operations such as multiplying a tensor\n by a scalar, broadcasting (usually) confers some time or space\n benefit, as the broadcasted tensor is never materialized.\n\n However, `broadcast_to` does not carry with it any such benefits.\n The newly-created tensor takes the full memory of the broadcasted\n shape. (In a graph context, `broadcast_to` might be fused to\n subsequent operation and then be optimized away, however.)\n\n Args:\n input: A `Tensor`. A Tensor to broadcast.\n shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n An 1-D `int` Tensor. The shape of the desired output.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "Broadcast an array for a compatible shape.", "type": "API"}, {"name": "tf.compat.v1.case", "docs": "Create a case operation.\n\n See also `tf.switch_case`.\n\n The `pred_fn_pairs` parameter is a dict or list of pairs of size N.\n Each pair contains a boolean scalar tensor and a python callable that\n creates the tensors to be returned if the boolean evaluates to True.\n `default` is a callable generating a list of tensors. All the callables\n in `pred_fn_pairs` as well as `default` (if provided) should return the same\n number and types of tensors.\n\n If `exclusive==True`, all predicates are evaluated, and an exception is\n thrown if more than one of the predicates evaluates to `True`.\n If `exclusive==False`, execution stops at the first predicate which\n evaluates to True, and the tensors generated by the corresponding function\n are returned immediately. If none of the predicates evaluate to True, this\n operation returns the tensors generated by `default`.\n\n `tf.case` supports nested structures as implemented in\n `tf.nest`. All of the callables must return the same (possibly nested) value\n structure of lists, tuples, and/or named tuples. Singleton lists and tuples\n form the only exceptions to this: when returned by a callable, they are\n implicitly unpacked to single values. This behavior is disabled by passing\n `strict=True`.\n\n If an unordered dictionary is used for `pred_fn_pairs`, the order of the\n conditional tests is not guaranteed. However, the order is guaranteed to be\n deterministic, so that variables created in conditional branches are created\n in fixed order across runs.\n\n @compatibility(eager)\n Unordered dictionaries are not supported in eager mode when `exclusive=False`.\n Use a list of tuples instead.\n @end_compatibility\n\n\n **Example 1:**\n\n Pseudocode:\n\n ```\n if (x < y) return 17;\n else return 23;\n ```\n\n Expressions:\n\n ```python\n f1 = lambda: tf.constant(17)\n f2 = lambda: tf.constant(23)\n r = tf.case([(tf.less(x, y), f1)], default=f2)\n ```\n\n **Example 2:**\n\n Pseudocode:\n\n ```\n if (x < y && x > z) raise OpError(\"Only one predicate may evaluate to True\");\n if (x < y) return 17;\n else if (x > z) return 23;\n else return -1;\n ```\n\n Expressions:\n\n ```python\n def f1(): return tf.constant(17)\n def f2(): return tf.constant(23)\n def f3(): return tf.constant(-1)\n r = tf.case({tf.less(x, y): f1, tf.greater(x, z): f2},\n default=f3, exclusive=True)\n ```\n\n Args:\n pred_fn_pairs: Dict or list of pairs of a boolean scalar tensor and a\n callable which returns a list of tensors.\n default: Optional callable that returns a list of tensors.\n exclusive: True iff at most one predicate is allowed to evaluate to `True`.\n strict: A boolean that enables/disables 'strict' mode; see above.\n name: A name for this operation (optional).\n\n Returns:\n The tensors returned by the first pair whose predicate evaluated to True, or\n those returned by `default` if none does.\n\n Raises:\n TypeError: If `pred_fn_pairs` is not a list/dictionary.\n TypeError: If `pred_fn_pairs` is a list but does not contain 2-tuples.\n TypeError: If `fns[i]` is not callable for any i, or `default` is not\n callable.\n ", "desc": "Create a case operation.", "type": "API"}, {"name": "tf.compat.v1.cast", "docs": "Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.cast(x, tf.int32)\n \n\n Notice `tf.cast` has an alias `tf.dtypes.cast`:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.dtypes.cast(x, tf.int32)\n \n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Note casting nan and inf values to integral types has undefined behavior.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n ", "desc": "Casts a tensor to a new type.", "type": "API"}, {"name": "tf.compat.v1.ceil", "docs": "Return the ceiling of the input, element-wise.\n\n For example:\n\n >>> tf.math.ceil([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n \n\n Args:\n x: A `tf.Tensor`. Must be one of the following types: `bfloat16`, `half`,\n `float32`, `float64`. `int32`\n name: A name for the operation (optional).\n\n Returns:\n A `tf.Tensor`. Has the same type as `x`.\n\n @compatibility(numpy)\n Equivalent to np.ceil\n @end_compatibility\n ", "desc": "Return the ceiling of the input, element-wise.", "type": "API"}, {"name": "tf.compat.v1.check_numerics", "docs": "Checks a tensor for NaN and Inf values.\n\n When run, reports an `InvalidArgument` error if `tensor` has any values\n that are not a number (NaN) or infinity (Inf). Otherwise, returns the input\n tensor.\n\n Example usage:\n\n ``` python\n a = tf.Variable(1.0)\n tf.debugging.check_numerics(a, message='')\n\n b = tf.Variable(np.nan)\n try:\n tf.debugging.check_numerics(b, message='Checking b')\n except Exception as e:\n assert \"Checking b : Tensor had NaN values\" in e.message\n\n c = tf.Variable(np.inf)\n try:\n tf.debugging.check_numerics(c, message='Checking c')\n except Exception as e:\n assert \"Checking c : Tensor had Inf values\" in e.message\n ```\n\n Args:\n tensor: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n message: A `string`. Prefix of the error message.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `tensor`.\n ", "desc": "Checks a tensor for NaN and Inf values.", "type": "API"}, {"name": "tf.compat.v1.cholesky", "docs": "Computes the Cholesky decomposition of one or more square matrices.\n\n The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions\n form square matrices.\n\n The input has to be symmetric and positive definite. Only the lower-triangular\n part of the input will be used for this operation. The upper-triangular part\n will not be read.\n\n The output is a tensor of the same shape as the input\n containing the Cholesky decompositions for all input submatrices `[..., :, :]`.\n\n **Note**: The gradient computation on GPU is faster for large matrices but\n not for large batch dimensions when the submatrices are small. In this\n case it might be faster to use the CPU.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.\n Shape is `[..., M, M]`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "Computes the Cholesky decomposition of one or more square matrices.", "type": "API"}, {"name": "tf.compat.v1.cholesky_solve", "docs": "Solves systems of linear eqns `A X = RHS`, given Cholesky factorizations.\n\n Specifically, returns `X` from `A X = RHS`, where `A = L L^T`, `L` is the\n `chol` arg and `RHS` is the `rhs` arg.\n\n ```python\n # Solve 10 separate 2x2 linear systems:\n A = ... # shape 10 x 2 x 2\n RHS = ... # shape 10 x 2 x 1\n chol = tf.linalg.cholesky(A) # shape 10 x 2 x 2\n X = tf.linalg.cholesky_solve(chol, RHS) # shape 10 x 2 x 1\n # tf.matmul(A, X) ~ RHS\n X[3, :, 0] # Solution to the linear system A[3, :, :] x = RHS[3, :, 0]\n\n # Solve five linear systems (K = 5) for every member of the length 10 batch.\n A = ... # shape 10 x 2 x 2\n RHS = ... # shape 10 x 2 x 5\n ...\n X[3, :, 2] # Solution to the linear system A[3, :, :] x = RHS[3, :, 2]\n ```\n\n Args:\n chol: A `Tensor`. Must be `float32` or `float64`, shape is `[..., M, M]`.\n Cholesky factorization of `A`, e.g. `chol = tf.linalg.cholesky(A)`.\n For that reason, only the lower triangular parts (including the diagonal)\n of the last two dimensions of `chol` are used. The strictly upper part is\n assumed to be zero and not accessed.\n rhs: A `Tensor`, same type as `chol`, shape is `[..., M, K]`.\n name: A name to give this `Op`. Defaults to `cholesky_solve`.\n\n Returns:\n Solution to `A x = rhs`, shape `[..., M, K]`.\n ", "desc": "Solves systems of linear eqns `A X = RHS`, given Cholesky factorizations.", "type": "API"}, {"name": "tf.compat.v1.clip_by_average_norm", "docs": "Clips tensor values to a maximum average L2-norm. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nclip_by_average_norm is deprecated in TensorFlow 2.0. Please use clip_by_norm(t, clip_norm * tf.cast(tf.size(t), tf.float32), name) instead.\n\nGiven a tensor `t`, and a maximum clip value `clip_norm`, this operation\nnormalizes `t` so that its average L2-norm is less than or equal to\n`clip_norm`. Specifically, if the average L2-norm is already less than or\nequal to `clip_norm`, then `t` is not modified. If the average L2-norm is\ngreater than `clip_norm`, then this operation returns a tensor of the same\ntype and shape as `t` with its values set to:\n\n`t * clip_norm / l2norm_avg(t)`\n\nIn this case, the average L2-norm of the output tensor is `clip_norm`.\n\nThis operation is typically used to clip gradients before applying them with\nan optimizer.\n\nArgs:\n t: A `Tensor`.\n clip_norm: A 0-D (scalar) `Tensor` > 0. A maximum clipping value.\n name: A name for the operation (optional).\n\nReturns:\n A clipped `Tensor`.", "desc": "Clips tensor values to a maximum average L2-norm. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.clip_by_global_norm", "docs": "Clips values of multiple tensors by the ratio of the sum of their norms.\n\n Given a tuple or list of tensors `t_list`, and a clipping ratio `clip_norm`,\n this operation returns a list of clipped tensors `list_clipped`\n and the global norm (`global_norm`) of all tensors in `t_list`. Optionally,\n if you've already computed the global norm for `t_list`, you can specify\n the global norm with `use_norm`.\n\n To perform the clipping, the values `t_list[i]` are set to:\n\n t_list[i] * clip_norm / max(global_norm, clip_norm)\n\n where:\n\n global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))\n\n If `clip_norm > global_norm` then the entries in `t_list` remain as they are,\n otherwise they're all shrunk by the global ratio.\n\n If `global_norm == infinity` then the entries in `t_list` are all set to `NaN`\n to signal that an error occurred.\n\n Any of the entries of `t_list` that are of type `None` are ignored.\n\n This is the correct way to perform gradient clipping (Pascanu et al., 2012).\n\n However, it is slower than `clip_by_norm()` because all the parameters must be\n ready before the clipping operation can be performed.\n\n Args:\n t_list: A tuple or list of mixed `Tensors`, `IndexedSlices`, or None.\n clip_norm: A 0-D (scalar) `Tensor` > 0. The clipping ratio.\n use_norm: A 0-D (scalar) `Tensor` of type `float` (optional). The global\n norm to use. If not provided, `global_norm()` is used to compute the norm.\n name: A name for the operation (optional).\n\n Returns:\n list_clipped: A list of `Tensors` of the same type as `list_t`.\n global_norm: A 0-D (scalar) `Tensor` representing the global norm.\n\n Raises:\n TypeError: If `t_list` is not a sequence.\n\n References:\n On the difficulty of training Recurrent Neural Networks:\n [Pascanu et al., 2012](http://proceedings.mlr.press/v28/pascanu13.html)\n ([pdf](http://proceedings.mlr.press/v28/pascanu13.pdf))\n ", "desc": "Clips values of multiple tensors by the ratio of the sum of their norms.", "type": "API"}, {"name": "tf.compat.v1.clip_by_norm", "docs": "Clips tensor values to a maximum L2-norm.\n\n Given a tensor `t`, and a maximum clip value `clip_norm`, this operation\n normalizes `t` so that its L2-norm is less than or equal to `clip_norm`,\n along the dimensions given in `axes`. Specifically, in the default case\n where all dimensions are used for calculation, if the L2-norm of `t` is\n already less than or equal to `clip_norm`, then `t` is not modified. If\n the L2-norm is greater than `clip_norm`, then this operation returns a\n tensor of the same type and shape as `t` with its values set to:\n\n `t * clip_norm / l2norm(t)`\n\n In this case, the L2-norm of the output tensor is `clip_norm`.\n\n As another example, if `t` is a matrix and `axes == [1]`, then each row\n of the output will have L2-norm less than or equal to `clip_norm`. If\n `axes == [0]` instead, each column of the output will be clipped.\n\n Code example:\n\n >>> some_nums = tf.constant([[1, 2, 3, 4, 5]], dtype=tf.float32)\n >>> tf.clip_by_norm(some_nums, 2.0).numpy()\n array([[0.26967996, 0.5393599 , 0.80903983, 1.0787199 , 1.3483998 ]],\n dtype=float32)\n\n This operation is typically used to clip gradients before applying them with\n an optimizer. Most gradient data is a collection of different shaped tensors\n for different parts of the model. Thus, this is a common usage:\n\n ```\n # Get your gradients after training\n loss_value, grads = grad(model, features, labels)\n\n # Apply some clipping\n grads = [tf.clip_by_norm(g, norm)\n for g in grads]\n\n # Continue on with training\n optimizer.apply_gradients(grads)\n ```\n\n Args:\n t: A `Tensor` or `IndexedSlices`. This must be a floating point type.\n clip_norm: A 0-D (scalar) `Tensor` > 0. A maximum clipping value, also\n floating point\n axes: A 1-D (vector) `Tensor` of type int32 containing the dimensions\n to use for computing the L2-norm. If `None` (the default), uses all\n dimensions.\n name: A name for the operation (optional).\n\n Returns:\n A clipped `Tensor` or `IndexedSlices`.\n\n Raises:\n ValueError: If the clip_norm tensor is not a 0-D scalar tensor.\n TypeError: If dtype of the input is not a floating point or\n complex type.\n ", "desc": "Clips tensor values to a maximum L2-norm.", "type": "API"}, {"name": "tf.compat.v1.clip_by_value", "docs": "Clips tensor values to a specified min and max.\n\n Given a tensor `t`, this operation returns a tensor of the same type and\n shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`.\n Any values less than `clip_value_min` are set to `clip_value_min`. Any values\n greater than `clip_value_max` are set to `clip_value_max`.\n\n Note: `clip_value_min` needs to be smaller or equal to `clip_value_max` for\n correct results.\n\n For example:\n\n Basic usage passes a scalar as the min and max value.\n\n >>> t = tf.constant([[-10., -1., 0.], [0., 2., 10.]])\n >>> t2 = tf.clip_by_value(t, clip_value_min=-1, clip_value_max=1)\n >>> t2.numpy()\n array([[-1., -1., 0.],\n [ 0., 1., 1.]], dtype=float32)\n\n The min and max can be the same size as `t`, or broadcastable to that size.\n\n >>> t = tf.constant([[-1, 0., 10.], [-1, 0, 10]])\n >>> clip_min = [[2],[1]]\n >>> t3 = tf.clip_by_value(t, clip_value_min=clip_min, clip_value_max=100)\n >>> t3.numpy()\n array([[ 2., 2., 10.],\n [ 1., 1., 10.]], dtype=float32)\n\n Broadcasting fails, intentionally, if you would expand the dimensions of `t`\n\n >>> t = tf.constant([[-1, 0., 10.], [-1, 0, 10]])\n >>> clip_min = [[[2, 1]]] # Has a third axis\n >>> t4 = tf.clip_by_value(t, clip_value_min=clip_min, clip_value_max=100)\n Traceback (most recent call last):\n ...\n InvalidArgumentError: Incompatible shapes: [2,3] vs. [1,1,2]\n\n It throws a `TypeError` if you try to clip an `int` to a `float` value\n (`tf.cast` the input to `float` first).\n\n >>> t = tf.constant([[1, 2], [3, 4]], dtype=tf.int32)\n >>> t5 = tf.clip_by_value(t, clip_value_min=-3.1, clip_value_max=3.1)\n Traceback (most recent call last):\n ...\n TypeError: Cannot convert ...\n\n\n Args:\n t: A `Tensor` or `IndexedSlices`.\n clip_value_min: The minimum value to clip to. A scalar `Tensor` or one that\n is broadcastable to the shape of `t`.\n clip_value_max: The maximum value to clip to. A scalar `Tensor` or one that\n is broadcastable to the shape of `t`.\n name: A name for the operation (optional).\n\n Returns:\n A clipped `Tensor` or `IndexedSlices`.\n\n Raises:\n `tf.errors.InvalidArgumentError`: If the clip tensors would trigger array\n broadcasting that would make the returned tensor larger than the input.\n TypeError: If dtype of the input is `int32` and dtype of\n the `clip_value_min` or `clip_value_max` is `float32`\n ", "desc": "Clips tensor values to a specified min and max.", "type": "API"}, {"name": "tf.compat.v1.colocate_with", "docs": "DEPRECATED FUNCTION\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nColocations handled automatically by placer.", "desc": "DEPRECATED FUNCTION", "type": "API"}, {"name": "tf.compat.v1.compat", "docs": "Compatibility functions.\n\nThe `tf.compat` module contains two sets of compatibility functions.\n\n## Tensorflow 1.x and 2.x APIs\n\nThe `compat.v1` and `compat.v2` submodules provide a complete copy of both the\n`v1` and `v2` APIs for backwards and forwards compatibility across TensorFlow\nversions 1.x and 2.x. See the\n[migration guide](https://www.tensorflow.org/guide/migrate) for details.\n\n## Utilities for writing compatible code\n\nAside from the `compat.v1` and `compat.v2` submodules, `tf.compat` also contains\na set of helper functions for writing code that works in both:\n\n* TensorFlow 1.x and 2.x\n* Python 2 and 3\n\n\n## Type collections\n\nThe compatibility module also provides the following aliases for common\nsets of python types:\n\n* `bytes_or_text_types`\n* `complex_types`\n* `integral_types`\n* `real_types`\n\n", "desc": "Compatibility functions.", "type": "API"}, {"name": "tf.compat.v1.compat.as_bytes", "docs": "Converts `bytearray`, `bytes`, or unicode python input types to `bytes`.\n\n Uses utf-8 encoding for text by default.\n\n Args:\n bytes_or_text: A `bytearray`, `bytes`, `str`, or `unicode` object.\n encoding: A string indicating the charset for encoding unicode.\n\n Returns:\n A `bytes` object.\n\n Raises:\n TypeError: If `bytes_or_text` is not a binary or unicode string.\n ", "desc": "Converts `bytearray`, `bytes`, or unicode python input types to `bytes`.", "type": "API"}, {"name": "tf.compat.v1.compat.as_str", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.compat.as_str_any", "docs": "Converts input to `str` type.\n\n Uses `str(value)`, except for `bytes` typed inputs, which are converted\n using `as_str`.\n\n Args:\n value: A object that can be converted to `str`.\n\n Returns:\n A `str` object.\n ", "desc": "Converts input to `str` type.", "type": "API"}, {"name": "tf.compat.v1.compat.as_text", "docs": "Converts any string-like python input types to unicode.\n\n Returns the input as a unicode string. Uses utf-8 encoding for text\n by default.\n\n Args:\n bytes_or_text: A `bytes`, `str`, or `unicode` object.\n encoding: A string indicating the charset for decoding unicode.\n\n Returns:\n A `unicode` (Python 2) or `str` (Python 3) object.\n\n Raises:\n TypeError: If `bytes_or_text` is not a binary or unicode string.\n ", "desc": "Converts any string-like python input types to unicode.", "type": "API"}, {"name": "tf.compat.v1.compat.dimension_at_index", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n If you want to retrieve the Dimension instance corresponding to a certain\n index in a TensorShape instance, use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n dim = tensor_shape[i]\n\n # Use `dimension_at_index` as direct replacement compatible with both V1 & V2:\n dim = dimension_at_index(tensor_shape, i)\n\n # Another possibility would be this, but WARNING: it only works if the\n # tensor_shape instance has a defined rank.\n dim = tensor_shape.dims[i] # `dims` may be None if the rank is undefined!\n\n # In native V2 code, we recommend instead being more explicit:\n if tensor_shape.rank is None:\n dim = Dimension(None)\n else:\n dim = tensor_shape.dims[i]\n\n # Being more explicit will save you from the following trap (present in V1):\n # you might do in-place modifications to `dim` and expect them to be reflected\n # in `tensor_shape[i]`, but they would not be (as the Dimension object was\n # instantiated on the fly.\n ```\n\n Args:\n shape: A TensorShape instance.\n index: An integer index.\n\n Returns:\n A dimension object.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.v1.compat.dimension_value", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n When accessing the value of a TensorShape dimension,\n use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n value = tensor_shape[i].value\n\n # Use `dimension_value` as direct replacement compatible with both V1 & V2:\n value = dimension_value(tensor_shape[i])\n\n # This would be the V2 equivalent:\n value = tensor_shape[i] # Warning: this will return the dim value in V2!\n ```\n\n Args:\n dimension: Either a `Dimension` instance, an integer, or None.\n\n Returns:\n A plain value, i.e. an integer or None.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.v1.compat.forward_compatibility_horizon", "docs": "Context manager for testing forward compatibility of generated graphs.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n To ensure forward compatibility of generated graphs (see `forward_compatible`)\n with older binaries, new features can be gated with:\n\n ```python\n if compat.forward_compatible(year=2018, month=08, date=01):\n generate_graph_with_new_features()\n else:\n generate_graph_so_older_binaries_can_consume_it()\n ```\n\n However, when adding new features, one may want to unittest it before\n the forward compatibility window expires. This context manager enables\n such tests. For example:\n\n ```python\n from tensorflow.python.compat import compat\n\n def testMyNewFeature(self):\n with compat.forward_compatibility_horizon(2018, 08, 02):\n # Test that generate_graph_with_new_features() has an effect\n ```\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Yields:\n Nothing.\n ", "desc": "Context manager for testing forward compatibility of generated graphs.", "type": "API"}, {"name": "tf.compat.v1.compat.forward_compatible", "docs": "Return true if the forward compatibility window has expired.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n Forward-compatibility refers to scenarios where the producer of a TensorFlow\n model (a GraphDef or SavedModel) is compiled against a version of the\n TensorFlow library newer than what the consumer was compiled against. The\n \"producer\" is typically a Python program that constructs and trains a model\n while the \"consumer\" is typically another program that loads and serves the\n model.\n\n TensorFlow has been supporting a 3 week forward-compatibility window for\n programs compiled from source at HEAD.\n\n For example, consider the case where a new operation `MyNewAwesomeAdd` is\n created with the intent of replacing the implementation of an existing Python\n wrapper - `tf.add`. The Python wrapper implementation should change from\n something like:\n\n ```python\n def add(inputs, name=None):\n return gen_math_ops.add(inputs, name)\n ```\n\n to:\n\n ```python\n from tensorflow.python.compat import compat\n\n def add(inputs, name=None):\n if compat.forward_compatible(year, month, day):\n # Can use the awesome new implementation.\n return gen_math_ops.my_new_awesome_add(inputs, name)\n # To maintain forward compatibility, use the old implementation.\n return gen_math_ops.add(inputs, name)\n ```\n\n Where `year`, `month`, and `day` specify the date beyond which binaries\n that consume a model are expected to have been updated to include the\n new operations. This date is typically at least 3 weeks beyond the date\n the code that adds the new operation is committed.\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Returns:\n True if the caller can expect that serialized TensorFlow graphs produced\n can be consumed by programs that are compiled with the TensorFlow library\n source code after (year, month, day).\n ", "desc": "Return true if the forward compatibility window has expired.", "type": "API"}, {"name": "tf.compat.v1.compat.path_to_str", "docs": "Converts input which is a `PathLike` object to `str` type.\n\n Converts from any python constant representation of a `PathLike` object to\n a string. If the input is not a `PathLike` object, simply returns the input.\n\n Args:\n path: An object that can be converted to path representation.\n\n Returns:\n A `str` object.\n\n Usage:\n In case a simplified `str` version of the path is needed from an\n `os.PathLike` object\n\n Examples:\n ```python\n $ tf.compat.path_to_str('C:\\XYZ\\tensorflow\\./.././tensorflow')\n 'C:\\XYZ\\tensorflow\\./.././tensorflow' # Windows OS\n $ tf.compat.path_to_str(Path('C:\\XYZ\\tensorflow\\./.././tensorflow'))\n 'C:\\XYZ\\tensorflow\\..\\tensorflow' # Windows OS\n $ tf.compat.path_to_str(Path('./corpus'))\n 'corpus' # Linux OS\n $ tf.compat.path_to_str('./.././Corpus')\n './.././Corpus' # Linux OS\n $ tf.compat.path_to_str(Path('./.././Corpus'))\n '../Corpus' # Linux OS\n $ tf.compat.path_to_str(Path('./..////../'))\n '../..' # Linux OS\n\n ```\n ", "desc": "Converts input which is a `PathLike` object to `str` type.", "type": "API"}, {"name": "tf.compat.v1.complex", "docs": "Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n\n Raises:\n TypeError: Real and imag must be correct types\n ", "desc": "Converts two real numbers to a complex number.", "type": "API"}, {"name": "tf.compat.v1.concat", "docs": "Concatenates tensors along one dimension.\n\n See also `tf.tile`, `tf.stack`, `tf.repeat`.\n\n Concatenates the list of tensors `values` along dimension `axis`. If\n `values[i].shape = [D0, D1, ... Daxis(i), ...Dn]`, the concatenated\n result has shape\n\n [D0, D1, ... Raxis, ...Dn]\n\n where\n\n Raxis = sum(Daxis(i))\n\n That is, the data from the input tensors is joined along the `axis`\n dimension.\n\n The number of dimensions of the input tensors must match, and all dimensions\n except `axis` must be equal.\n\n For example:\n\n >>> t1 = [[1, 2, 3], [4, 5, 6]]\n >>> t2 = [[7, 8, 9], [10, 11, 12]]\n >>> tf.concat([t1, t2], 0)\n \n\n >>> tf.concat([t1, t2], 1)\n \n\n As in Python, the `axis` could also be negative numbers. Negative `axis`\n are interpreted as counting from the end of the rank, i.e.,\n `axis + rank(values)`-th dimension.\n\n For example:\n\n >>> t1 = [[[1, 2], [2, 3]], [[4, 4], [5, 3]]]\n >>> t2 = [[[7, 4], [8, 4]], [[2, 10], [15, 11]]]\n >>> tf.concat([t1, t2], -1)\n \n\n Note: If you are concatenating along a new axis consider using stack.\n E.g.\n\n ```python\n tf.concat([tf.expand_dims(t, axis) for t in tensors], axis)\n ```\n\n can be rewritten as\n\n ```python\n tf.stack(tensors, axis=axis)\n ```\n\n Args:\n values: A list of `Tensor` objects or a single `Tensor`.\n axis: 0-D `int32` `Tensor`. Dimension along which to concatenate. Must be\n in the range `[-rank(values), rank(values))`. As in Python, indexing for\n axis is 0-based. Positive axis in the rage of `[0, rank(values))` refers\n to `axis`-th dimension. And negative axis refers to `axis +\n rank(values)`-th dimension.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` resulting from concatenation of the input tensors.\n ", "desc": "Concatenates tensors along one dimension.", "type": "API"}, {"name": "tf.compat.v1.cond", "docs": "Return `true_fn()` if the predicate `pred` is true else `false_fn()`. (deprecated arguments)\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(fn1, fn2)`. They will be removed in a future version.\nInstructions for updating:\nfn1/fn2 are deprecated in favor of the true_fn/false_fn arguments.\n\n`true_fn` and `false_fn` both return lists of output tensors. `true_fn` and\n`false_fn` must have the same non-zero number and type of outputs.\n\n**WARNING**: Any Tensors or Operations created outside of `true_fn` and\n`false_fn` will be executed regardless of which branch is selected at runtime.\n\nAlthough this behavior is consistent with the dataflow model of TensorFlow,\nit has frequently surprised users who expected a lazier semantics.\nConsider the following simple program:\n\n```python\nz = tf.multiply(a, b)\nresult = tf.cond(x < y, lambda: tf.add(x, z), lambda: tf.square(y))\n```\n\nIf `x < y`, the `tf.add` operation will be executed and `tf.square`\noperation will not be executed. Since `z` is needed for at least one\nbranch of the `cond`, the `tf.multiply` operation is always executed,\nunconditionally.\n\nNote that `cond` calls `true_fn` and `false_fn` *exactly once* (inside the\ncall to `cond`, and not at all during `Session.run()`). `cond`\nstitches together the graph fragments created during the `true_fn` and\n`false_fn` calls with some additional graph nodes to ensure that the right\nbranch gets executed depending on the value of `pred`.\n\n`tf.cond` supports nested structures as implemented in\n`tensorflow.python.util.nest`. Both `true_fn` and `false_fn` must return the\nsame (possibly nested) value structure of lists, tuples, and/or named tuples.\nSingleton lists and tuples form the only exceptions to this: when returned by\n`true_fn` and/or `false_fn`, they are implicitly unpacked to single values.\nThis behavior is disabled by passing `strict=True`.\n\nArgs:\n pred: A scalar determining whether to return the result of `true_fn` or\n `false_fn`.\n true_fn: The callable to be performed if pred is true.\n false_fn: The callable to be performed if pred is false.\n strict: A boolean that enables/disables 'strict' mode; see above.\n name: Optional name prefix for the returned tensors.\n\nReturns:\n Tensors returned by the call to either `true_fn` or `false_fn`. If the\n callables return a singleton list, the element is extracted from the list.\n\nRaises:\n TypeError: if `true_fn` or `false_fn` is not callable.\n ValueError: if `true_fn` and `false_fn` do not return the same number of\n tensors, or return tensors of different types.\n\nExample:\n\n```python\nx = tf.constant(2)\ny = tf.constant(5)\ndef f1(): return tf.multiply(x, 17)\ndef f2(): return tf.add(y, 23)\nr = tf.cond(tf.less(x, y), f1, f2)\n# r is set to f1().\n# Operations in f2 (e.g., tf.add) are not executed.\n```", "desc": "Return `true_fn()` if the predicate `pred` is true else `false_fn()`. (deprecated arguments)", "type": "API"}, {"name": "tf.compat.v1.ConditionalAccumulator", "docs": "A conditional accumulator for aggregating gradients.\n\n Up-to-date gradients (i.e., time step at which gradient was computed is\n equal to the accumulator's time step) are added to the accumulator.\n\n Extraction of the average gradient is blocked until the required number of\n gradients has been accumulated.\n ", "desc": "A conditional accumulator for aggregating gradients.", "type": "API"}, {"name": "tf.compat.v1.ConditionalAccumulatorBase", "docs": "A conditional accumulator for aggregating gradients.\n\n Up-to-date gradients (i.e., time step at which gradient was computed is\n equal to the accumulator's time step) are added to the accumulator.\n\n Extraction of the average gradient is blocked until the required number of\n gradients has been accumulated.\n ", "desc": "A conditional accumulator for aggregating gradients.", "type": "API"}, {"name": "tf.compat.v1.config", "docs": "Public API for tf.config namespace.\n", "desc": "Public API for tf.config namespace.", "type": "API"}, {"name": "tf.compat.v1.config.experimental", "docs": "Public API for tf.config.experimental namespace.\n", "desc": "Public API for tf.config.experimental namespace.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.ClusterDeviceFilters", "docs": "Represent a collection of device filters for the remote workers in cluster.\n\n NOTE: this is an experimental API and subject to changes.\n\n Set device filters for selective jobs and tasks. For each remote worker, the\n device filters are a list of strings. When any filters are present, the remote\n worker will ignore all devices which do not match any of its filters. Each\n filter can be partially specified, e.g. \"/job:ps\", \"/job:worker/replica:3\",\n etc. Note that a device is always visible to the worker it is located on.\n\n For example, to set the device filters for a parameter server cluster:\n\n ```python\n cdf = tf.config.experimental.ClusterDeviceFilters()\n for i in range(num_workers):\n cdf.set_device_filters('worker', i, ['/job:ps'])\n for i in range(num_ps):\n cdf.set_device_filters('ps', i, ['/job:worker'])\n\n tf.config.experimental_connect_to_cluster(cluster_def,\n cluster_device_filters=cdf)\n ```\n\n The device filters can be partically specified. For remote tasks that do not\n have device filters specified, all devices will be visible to them.\n ", "desc": "Represent a collection of device filters for the remote workers in cluster.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.disable_mlir_bridge", "docs": "Disables experimental MLIR-Based TensorFlow Compiler Bridge.", "desc": "Disables experimental MLIR-Based TensorFlow Compiler Bridge.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.disable_mlir_graph_optimization", "docs": "Disables experimental MLIR-Based TensorFlow Compiler Optimizations.", "desc": "Disables experimental MLIR-Based TensorFlow Compiler Optimizations.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.enable_mlir_bridge", "docs": "Enables experimental MLIR-Based TensorFlow Compiler Bridge.\n\n DO NOT USE, DEV AND TESTING ONLY AT THE MOMENT.\n\n NOTE: MLIR-Based TensorFlow Compiler is under active development and has\n missing features, please refrain from using. This API exists for development\n and testing only.\n\n TensorFlow Compiler Bridge (TF Bridge) is responsible for translating parts\n of TensorFlow graph into a form that can be accepted as an input by a backend\n compiler such as XLA.\n ", "desc": "Enables experimental MLIR-Based TensorFlow Compiler Bridge.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.enable_mlir_graph_optimization", "docs": "Enables experimental MLIR-Based TensorFlow Compiler Optimizations.\n\n DO NOT USE, DEV AND TESTING ONLY AT THE MOMENT.\n\n NOTE: MLIR-Based TensorFlow Compiler is under active development and has\n missing features, please refrain from using. This API exists for development\n and testing only.\n\n TensorFlow Compiler Optimizations are responsible general graph level\n optimizations that in the current stack mostly done by Grappler graph\n optimizers.\n ", "desc": "Enables experimental MLIR-Based TensorFlow Compiler Optimizations.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.enable_tensor_float_32_execution", "docs": "Enable or disable the use of TensorFloat-32 on supported hardware.\n\n [TensorFloat-32](https://blogs.nvidia.com/blog/2020/05/14/tensorfloat-32-precision-format),\n or TF32 for short, is a math mode for NVIDIA Ampere GPUs. TensorFloat-32\n execution causes certain float32 ops, such as matrix multiplications and\n convolutions, to run much faster on Ampere GPUs but with reduced precision.\n This reduced precision should not impact convergence of deep learning models\n in practice.\n\n TensorFloat-32 is enabled by default. TensorFloat-32 is only supported on\n Ampere GPUs, so all other hardware will use the full float32 precision\n regardless of whether TensorFloat-32 is enabled or not. If you want to use the\n full float32 precision on Ampere, you can disable TensorFloat-32 execution\n with this function. For example:\n\n ```python\n x = tf.fill((2, 2), 1.0001)\n y = tf.fill((2, 2), 1.)\n # TensorFloat-32 is enabled, so matmul is run with reduced precision\n print(tf.linalg.matmul(x, y)) # [[2., 2.], [2., 2.]]\n tf.config.experimental.enable_tensor_float_32_execution(False)\n # Matmul is run with full precision\n print(tf.linalg.matmul(x, y)) # [[2.0002, 2.0002], [2.0002, 2.0002]]\n ```\n\n To check whether TensorFloat-32 execution is currently enabled, use\n `tf.config.experimental.tensor_float_32_execution_enabled`.\n\n If TensorFloat-32 is enabled, float32 inputs of supported ops, such as\n `tf.linalg.matmul`, will be rounded from 23 bits of precision to 10 bits of\n precision in most cases. This allows the ops to execute much faster by\n utilizing the GPU's tensor cores. TensorFloat-32 has the same dynamic range as\n float32, meaning it is no more likely to underflow or overflow than float32.\n Ops still use float32 accumulation when TensorFloat-32 is enabled. Enabling or\n disabling TensorFloat-32 only affects Ampere GPUs and subsequent GPUs that\n support TensorFloat-32.\n\n Note TensorFloat-32 is not always used in supported ops, as only inputs of\n certain shapes are supported. Support for more input shapes and more ops may\n be added in the future. As a result, precision of float32 ops may decrease in\n minor versions of TensorFlow.\n\n TensorFloat-32 is also used for some complex64 ops. Currently, TensorFloat-32\n is used in fewer cases for complex64 as it is for float32.\n\n Args:\n enabled: Bool indicating whether to enable TensorFloat-32 execution.\n ", "desc": "Enable or disable the use of TensorFloat-32 on supported hardware.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_device_details", "docs": "Returns details about a physical devices.\n\n This API takes in a `tf.config.PhysicalDevice` returned by\n `tf.config.list_physical_devices`. It returns a dict with string keys\n containing various details about the device. Each key is only supported by a\n subset of devices, so you should not assume the returned dict will have any\n particular key.\n\n >>> gpu_devices = tf.config.list_physical_devices('GPU')\n >>> if gpu_devices:\n ... details = tf.config.experimental.get_device_details(gpu_devices[0])\n ... details.get('device_name', 'Unknown GPU')\n\n Currently, details are only returned for GPUs. This function returns an\n empty dict if passed a non-GPU device.\n\n The returned dict may have the following keys:\n * `'device_name'`: A human-readable name of the device as a string, e.g.\n \"Titan V\". Unlike `tf.config.PhysicalDevice.name`, this will be the same for\n multiple devices if each device is the same model. Currently only available\n for GPUs.\n * `'compute_capability'`: The\n [compute capability](https://developer.nvidia.com/cuda-gpus) of the device\n as a tuple of two ints, in the form `(major_version, minor_version)`. Only\n available for NVIDIA GPUs\n\n Note: This is similar to `tf.sysconfig.get_build_info` in that both functions\n can return information relating to GPUs. However, this function returns\n run-time information about a specific device (such as a GPU's compute\n capability), while `tf.sysconfig.get_build_info` returns compile-time\n information about how TensorFlow was built (such as what version of CUDA\n TensorFlow was built for).\n\n Args:\n device: A `tf.config.PhysicalDevice` returned by\n `tf.config.list_physical_devices` or `tf.config.get_visible_devices`.\n\n Returns:\n A dict with string keys.\n ", "desc": "Returns details about a physical devices.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_device_policy", "docs": "Gets the current device policy.\n\n The device policy controls how operations requiring inputs on a specific\n device (e.g., on GPU:0) handle inputs on a different device (e.g. GPU:1).\n\n This function only gets the device policy for the current thread. Any\n subsequently started thread will again use the default policy.\n\n Returns:\n Current thread device policy\n ", "desc": "Gets the current device policy.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_memory_growth", "docs": "Get if memory growth is enabled for a `PhysicalDevice`.\n\n If memory growth is enabled for a `PhysicalDevice`, the runtime initialization\n will not allocate all memory on the device.\n\n For example:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... tf.config.experimental.set_memory_growth(physical_devices[0], True)\n ... assert tf.config.experimental.get_memory_growth(physical_devices[0])\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device: `PhysicalDevice` to query\n\n Returns:\n A boolean indicating the memory growth setting for the `PhysicalDevice`.\n\n Raises:\n ValueError: Invalid `PhysicalDevice` specified.\n ", "desc": "Get if memory growth is enabled for a `PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_memory_info", "docs": "Get memory info for the chosen device, as a dict.\n\n This function returns a dict containing information about the device's memory\n usage. For example:\n\n >>> if tf.config.list_physical_devices('GPU'):\n ... # Returns a dict in the form {'current': ,\n ... # 'peak': }\n ... tf.config.experimental.get_memory_info('GPU:0')\n\n Currently returns the following keys:\n - `'current'`: The current memory used by the device, in bytes.\n - `'peak'`: The peak memory used by the device across the run of the\n program, in bytes. Can be reset with\n `tf.config.experimental.reset_memory_stats`.\n\n More keys may be added in the future, including device-specific keys.\n\n Currently only supports GPU and TPU. If called on a CPU device, an exception\n will be raised.\n\n For GPUs, TensorFlow will allocate all the memory by default, unless changed\n with `tf.config.experimental.set_memory_growth`. The dict specifies only the\n current and peak memory that TensorFlow is actually using, not the memory that\n TensorFlow has allocated on the GPU.\n\n Args:\n device: Device string to get the memory information for, e.g. `\"GPU:0\"`,\n `\"TPU:0\"`. See https://www.tensorflow.org/api_docs/python/tf/device for\n specifying device strings.\n\n Returns:\n A dict with keys `'current'` and `'peak'`, specifying the current and peak\n memory usage respectively.\n\n Raises:\n ValueError: No device found with the device name, like '\"nonexistent\"'.\n ValueError: Invalid device name, like '\"GPU\"', '\"CPU:GPU\"', '\"CPU:\"'.\n ValueError: Multiple devices matched with the device name.\n ValueError: Memory statistics not tracked, like '\"CPU:0\"'.\n ", "desc": "Get memory info for the chosen device, as a dict.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_memory_usage", "docs": "Get the current memory usage, in bytes, for the chosen device. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse tf.config.experimental.get_memory_info(device)['current'] instead.\n\nThis function is deprecated in favor of\n`tf.config.experimental.get_memory_info`. Calling this function is equivalent\nto calling `tf.config.experimental.get_memory_info()['current']`.\n\nSee https://www.tensorflow.org/api_docs/python/tf/device for specifying device\nstrings.\n\nFor example:\n\n>>> gpu_devices = tf.config.list_physical_devices('GPU')\n>>> if gpu_devices:\n... tf.config.experimental.get_memory_usage('GPU:0')\n\nDoes not work for CPU.\n\nFor GPUs, TensorFlow will allocate all the memory by default, unless changed\nwith `tf.config.experimental.set_memory_growth`. This function only returns\nthe memory that TensorFlow is actually using, not the memory that TensorFlow\nhas allocated on the GPU.\n\nArgs:\n device: Device string to get the bytes in use for, e.g. `\"GPU:0\"`\n\nReturns:\n Total memory usage in bytes.\n\nRaises:\n ValueError: Non-existent or CPU device specified.", "desc": "Get the current memory usage, in bytes, for the chosen device. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_synchronous_execution", "docs": "Gets whether operations are executed synchronously or asynchronously.\n\n TensorFlow can execute operations synchronously or asynchronously. If\n asynchronous execution is enabled, operations may return \"non-ready\" handles.\n\n Returns:\n Current thread execution mode\n ", "desc": "Gets whether operations are executed synchronously or asynchronously.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_virtual_device_configuration", "docs": "Get the virtual device configuration for a `tf.config.PhysicalDevice`.\n\n Returns the list of `tf.config.LogicalDeviceConfiguration`\n objects previously configured by a call to\n `tf.config.set_logical_device_configuration`.\n\n For example:\n\n >>> physical_devices = tf.config.list_physical_devices('CPU')\n >>> assert len(physical_devices) == 1, \"No CPUs found\"\n >>> configs = tf.config.get_logical_device_configuration(\n ... physical_devices[0])\n >>> try:\n ... assert configs is None\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... configs = tf.config.get_logical_device_configuration(\n ... physical_devices[0])\n ... assert len(configs) == 2\n ... except:\n ... # Cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device: `PhysicalDevice` to query\n\n Returns:\n List of `tf.config.LogicalDeviceConfiguration` objects or\n `None` if no virtual device configuration has been set for this physical\n device.\n ", "desc": "Get the virtual device configuration for a `tf.config.PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.get_visible_devices", "docs": "Get the list of visible physical devices.\n\n Returns the list of `PhysicalDevice`s currently marked as visible to the\n runtime. A visible device will have at least one `LogicalDevice` associated\n with it once the runtime is initialized.\n\n The following example verifies all visible GPUs have been disabled:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... # Disable all GPUS\n ... tf.config.set_visible_devices([], 'GPU')\n ... visible_devices = tf.config.get_visible_devices()\n ... for device in visible_devices:\n ... assert device.device_type != 'GPU'\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of visible `PhysicalDevice`s\n ", "desc": "Get the list of visible physical devices.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.list_logical_devices", "docs": "Return a list of logical devices created by runtime.\n\n Logical devices may correspond to physical devices or remote devices in the\n cluster. Operations and tensors may be placed on these devices by using the\n `name` of the `tf.config.LogicalDevice`.\n\n Calling `tf.config.list_logical_devices` triggers the runtime to configure any\n `tf.config.PhysicalDevice` visible to the runtime, thereby preventing\n further configuration. To avoid runtime initialization, call\n `tf.config.list_physical_devices` instead.\n\n For example:\n\n >>> logical_devices = tf.config.list_logical_devices('GPU')\n >>> if len(logical_devices) > 0:\n ... # Allocate on GPU:0\n ... with tf.device(logical_devices[0].name):\n ... one = tf.constant(1)\n ... # Allocate on GPU:1\n ... with tf.device(logical_devices[1].name):\n ... two = tf.constant(2)\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of initialized `LogicalDevice`s\n ", "desc": "Return a list of logical devices created by runtime.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.list_physical_devices", "docs": "Return a list of physical devices visible to the host runtime.\n\n Physical devices are hardware devices present on the host machine. By default\n all discovered CPU and GPU devices are considered visible.\n\n This API allows querying the physical hardware resources prior to runtime\n initialization. Thus, giving an opportunity to call any additional\n configuration APIs. This is in contrast to `tf.config.list_logical_devices`,\n which triggers runtime initialization in order to list the configured devices.\n\n The following example lists the number of visible GPUs on the host.\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> print(\"Num GPUs:\", len(physical_devices))\n Num GPUs: ...\n\n However, the number of GPUs available to the runtime may change during runtime\n initialization due to marking certain devices as not visible or configuring\n multiple logical devices.\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of discovered `tf.config.PhysicalDevice` objects\n ", "desc": "Return a list of physical devices visible to the host runtime.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.set_device_policy", "docs": "Sets the current thread device policy.\n\n The device policy controls how operations requiring inputs on a specific\n device (e.g., on GPU:0) handle inputs on a different device (e.g. GPU:1).\n\n When using the default, an appropriate policy will be picked automatically.\n The default policy may change over time.\n\n This function only sets the device policy for the current thread. Any\n subsequently started thread will again use the default policy.\n\n Args:\n device_policy: A device policy.\n Valid values:\n - None: Switch to a system default.\n - 'warn': Copies the tensors which are not on the right device and logs a\n warning.\n - 'explicit': Raises an error if the placement is not as required.\n - 'silent': Silently copies the tensors. Note that this may hide\n performance problems as there is no notification provided when\n operations are blocked on the tensor being copied between devices.\n - 'silent_for_int32': silently copies `int32` tensors, raising errors on\n the other ones.\n\n Raises:\n ValueError: If an invalid `device_policy` is passed.\n ", "desc": "Sets the current thread device policy.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.set_memory_growth", "docs": "Set if memory growth should be enabled for a `PhysicalDevice`.\n\n If memory growth is enabled for a `PhysicalDevice`, the runtime initialization\n will not allocate all memory on the device. Memory growth cannot be configured\n on a `PhysicalDevice` with virtual devices configured.\n\n For example:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... tf.config.experimental.set_memory_growth(physical_devices[0], True)\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device: `PhysicalDevice` to configure\n enable: (Boolean) Whether to enable or disable memory growth\n\n Raises:\n ValueError: Invalid `PhysicalDevice` specified.\n RuntimeError: Runtime is already initialized.\n ", "desc": "Set if memory growth should be enabled for a `PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.set_synchronous_execution", "docs": "Specifies whether operations are executed synchronously or asynchronously.\n\n TensorFlow can execute operations synchronously or asynchronously. If\n asynchronous execution is enabled, operations may return \"non-ready\" handles.\n\n When `enable` is set to None, an appropriate value will be picked\n automatically. The value picked may change between TensorFlow releases.\n\n Args:\n enable: Whether operations should be dispatched synchronously.\n Valid values:\n - None: sets the system default.\n - True: executes each operation synchronously.\n - False: executes each operation asynchronously.\n ", "desc": "Specifies whether operations are executed synchronously or asynchronously.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.set_virtual_device_configuration", "docs": "Set the logical device configuration for a `tf.config.PhysicalDevice`.\n\n A visible `tf.config.PhysicalDevice` will by default have a single\n `tf.config.LogicalDevice` associated with it once the runtime is initialized.\n Specifying a list of `tf.config.LogicalDeviceConfiguration` objects allows\n multiple devices to be created on the same `tf.config.PhysicalDevice`.\n\n Logical device configurations can be modified by calling this function as\n long as the runtime is uninitialized. After the runtime is initialized\n calling this function raises a RuntimeError.\n\n The following example splits the CPU into 2 logical devices:\n\n >>> physical_devices = tf.config.list_physical_devices('CPU')\n >>> assert len(physical_devices) == 1, \"No CPUs found\"\n >>> # Specify 2 virtual CPUs. Note currently memory limit is not supported.\n >>> try:\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... logical_devices = tf.config.list_logical_devices('CPU')\n ... assert len(logical_devices) == 2\n ...\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... except:\n ... # Cannot modify logical devices once initialized.\n ... pass\n\n The following example splits the GPU into 2 logical devices with 100 MB each:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(memory_limit=100),\n ... tf.config.LogicalDeviceConfiguration(memory_limit=100)])\n ...\n ... logical_devices = tf.config.list_logical_devices('GPU')\n ... assert len(logical_devices) == len(physical_devices) + 1\n ...\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(memory_limit=10),\n ... tf.config.LogicalDeviceConfiguration(memory_limit=10)])\n ... except:\n ... # Invalid device or cannot modify logical devices once initialized.\n ... pass\n\n Args:\n device: The `PhysicalDevice` to configure.\n logical_devices: (optional) List of `tf.config.LogicalDeviceConfiguration`\n objects to allocate for the specified `PhysicalDevice`. If None, the\n default configuration will be used.\n\n Raises:\n ValueError: If argument validation fails.\n RuntimeError: Runtime is already initialized.\n ", "desc": "Set the logical device configuration for a `tf.config.PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.set_visible_devices", "docs": "Set the list of visible devices.\n\n Specifies which `PhysicalDevice` objects are visible to the runtime.\n TensorFlow will only allocate memory and place operations on visible\n physical devices, as otherwise no `LogicalDevice` will be created on them.\n By default all discovered devices are marked as visible.\n\n The following example demonstrates disabling the first GPU on the machine.\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... # Disable first GPU\n ... tf.config.set_visible_devices(physical_devices[1:], 'GPU')\n ... logical_devices = tf.config.list_logical_devices('GPU')\n ... # Logical device was not created for first GPU\n ... assert len(logical_devices) == len(physical_devices) - 1\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n devices: List of `PhysicalDevice`s to make visible\n device_type: (optional) Only configure devices matching this device type.\n For example \"CPU\" or \"GPU\". Other devices will be left unaltered.\n\n Raises:\n ValueError: If argument validation fails.\n RuntimeError: Runtime is already initialized.\n ", "desc": "Set the list of visible devices.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.tensor_float_32_execution_enabled", "docs": "Returns whether TensorFloat-32 is enabled.\n\n By default, TensorFloat-32 is enabled, but this can be changed with\n `tf.config.experimental.enable_tensor_float_32_execution`.\n\n Returns:\n True if TensorFloat-32 is enabled (the default) and False otherwise\n ", "desc": "Returns whether TensorFloat-32 is enabled.", "type": "API"}, {"name": "tf.compat.v1.config.experimental.VirtualDeviceConfiguration", "docs": "Configuration class for a logical devices.\n\n The class specifies the parameters to configure a `tf.config.PhysicalDevice`\n as it is initialized to a `tf.config.LogicalDevice` during runtime\n initialization. Not all fields are valid for all device types.\n\n See `tf.config.get_logical_device_configuration` and\n `tf.config.set_logical_device_configuration` for usage examples.\n\n Fields:\n memory_limit: (optional) Maximum memory (in MB) to allocate on the virtual\n device. Currently only supported for GPUs.\n experimental_priority: (optional) Priority to assign to a virtual device.\n Lower values have higher priorities and 0 is the default.\n Within a physical GPU, the GPU scheduler will prioritize ops on virtual\n devices with higher priority. Currently only supported for Nvidia GPUs.\n ", "desc": "Configuration class for a logical devices.", "type": "API"}, {"name": "tf.compat.v1.config.experimental_connect_to_cluster", "docs": "Connects to the given cluster.\n\n Will make devices on the cluster available to use. Note that calling this more\n than once will work, but will invalidate any tensor handles on the old remote\n devices.\n\n If the given local job name is not present in the cluster specification, it\n will be automatically added, using an unused port on the localhost.\n\n Device filters can be specified to isolate groups of remote tasks to avoid\n undesired accesses between workers. Workers accessing resources or launching\n ops / functions on filtered remote devices will result in errors (unknown\n devices). For any remote task, if no device filter is present, all cluster\n devices will be visible; if any device filter is specified, it can only\n see devices matching at least one filter. Devices on the task itself are\n always visible. Device filters can be particially specified.\n\n For example, for a cluster set up for parameter server training, the following\n device filters might be specified:\n\n ```python\n cdf = tf.config.experimental.ClusterDeviceFilters()\n # For any worker, only the devices on PS nodes and itself are visible\n for i in range(num_workers):\n cdf.set_device_filters('worker', i, ['/job:ps'])\n # Similarly for any ps, only the devices on workers and itself are visible\n for i in range(num_ps):\n cdf.set_device_filters('ps', i, ['/job:worker'])\n\n tf.config.experimental_connect_to_cluster(cluster_def,\n cluster_device_filters=cdf)\n ```\n\n Args:\n cluster_spec_or_resolver: A `ClusterSpec` or `ClusterResolver` describing\n the cluster.\n job_name: The name of the local job.\n task_index: The local task index.\n protocol: The communication protocol, such as `\"grpc\"`. If unspecified, will\n use the default from `python/platform/remote_utils.py`.\n make_master_device_default: If True and a cluster resolver is passed, will\n automatically enter the master task device scope, which indicates the\n master becomes the default device to run ops. It won't do anything if\n a cluster spec is passed. Will throw an error if the caller is currently\n already in some device scope.\n cluster_device_filters: an instance of\n `tf.train.experimental/ClusterDeviceFilters` that specify device filters\n to the remote tasks in cluster.\n ", "desc": "Connects to the given cluster.", "type": "API"}, {"name": "tf.compat.v1.config.experimental_connect_to_host", "docs": "Connects to a single machine to enable remote execution on it.\n\n Will make devices on the remote host available to use. Note that calling this\n more than once will work, but will invalidate any tensor handles on the old\n remote devices.\n\n Using the default job_name of worker, you can schedule ops to run remotely as\n follows:\n ```python\n # When eager execution is enabled, connect to the remote host.\n tf.config.experimental_connect_to_host(\"exampleaddr.com:9876\")\n\n with ops.device(\"job:worker/replica:0/task:1/device:CPU:0\"):\n # The following tensors should be resident on the remote device, and the op\n # will also execute remotely.\n x1 = array_ops.ones([2, 2])\n x2 = array_ops.ones([2, 2])\n y = math_ops.matmul(x1, x2)\n ```\n\n Args:\n remote_host: a single or a list the remote server addr in host-port format.\n job_name: The job name under which the new server will be accessible.\n\n Raises:\n ValueError: if remote_host is None.\n ", "desc": "Connects to a single machine to enable remote execution on it.", "type": "API"}, {"name": "tf.compat.v1.config.experimental_functions_run_eagerly", "docs": "Returns the value of the `experimental_run_functions_eagerly` setting. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse tf.config.functions_run_eagerly instead of the experimental version.", "desc": "Returns the value of the `experimental_run_functions_eagerly` setting. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.config.experimental_run_functions_eagerly", "docs": "Enables / disables eager execution of `tf.function`s. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.config.run_functions_eagerly` instead of the experimental version.\n\nCalling `tf.config.experimental_run_functions_eagerly(True)` will make all\ninvocations of `tf.function` run eagerly instead of running as a traced graph\nfunction.\n\nSee `tf.config.run_functions_eagerly` for an example.\n\nNote: This flag has no effect on functions passed into tf.data transformations\nas arguments. tf.data functions are never executed eagerly and are always\nexecuted as a compiled Tensorflow Graph.\n\nArgs:\n run_eagerly: Boolean. Whether to run functions eagerly.", "desc": "Enables / disables eager execution of `tf.function`s. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.config.functions_run_eagerly", "docs": "Returns the value of the `run_functions_eagerly` setting.", "desc": "Returns the value of the `run_functions_eagerly` setting.", "type": "API"}, {"name": "tf.compat.v1.config.get_logical_device_configuration", "docs": "Get the virtual device configuration for a `tf.config.PhysicalDevice`.\n\n Returns the list of `tf.config.LogicalDeviceConfiguration`\n objects previously configured by a call to\n `tf.config.set_logical_device_configuration`.\n\n For example:\n\n >>> physical_devices = tf.config.list_physical_devices('CPU')\n >>> assert len(physical_devices) == 1, \"No CPUs found\"\n >>> configs = tf.config.get_logical_device_configuration(\n ... physical_devices[0])\n >>> try:\n ... assert configs is None\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... configs = tf.config.get_logical_device_configuration(\n ... physical_devices[0])\n ... assert len(configs) == 2\n ... except:\n ... # Cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device: `PhysicalDevice` to query\n\n Returns:\n List of `tf.config.LogicalDeviceConfiguration` objects or\n `None` if no virtual device configuration has been set for this physical\n device.\n ", "desc": "Get the virtual device configuration for a `tf.config.PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.get_soft_device_placement", "docs": "Return status of soft device placement flag.\n\n If enabled, an op will be placed on CPU if any of the following are true\n 1. there's no GPU implementation for the OP\n 2. no GPU devices are known or registered\n 3. need to co-locate with reftype input(s) which are from CPU\n\n If disabled, the placement is strict and CPU fallback is not allowed.\n An error is raised when an Op cannot be placed onto its intended device.\n\n Returns:\n A boolean indicating if soft placement is enabled.\n ", "desc": "Return status of soft device placement flag.", "type": "API"}, {"name": "tf.compat.v1.config.get_visible_devices", "docs": "Get the list of visible physical devices.\n\n Returns the list of `PhysicalDevice`s currently marked as visible to the\n runtime. A visible device will have at least one `LogicalDevice` associated\n with it once the runtime is initialized.\n\n The following example verifies all visible GPUs have been disabled:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... # Disable all GPUS\n ... tf.config.set_visible_devices([], 'GPU')\n ... visible_devices = tf.config.get_visible_devices()\n ... for device in visible_devices:\n ... assert device.device_type != 'GPU'\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of visible `PhysicalDevice`s\n ", "desc": "Get the list of visible physical devices.", "type": "API"}, {"name": "tf.compat.v1.config.list_logical_devices", "docs": "Return a list of logical devices created by runtime.\n\n Logical devices may correspond to physical devices or remote devices in the\n cluster. Operations and tensors may be placed on these devices by using the\n `name` of the `tf.config.LogicalDevice`.\n\n Calling `tf.config.list_logical_devices` triggers the runtime to configure any\n `tf.config.PhysicalDevice` visible to the runtime, thereby preventing\n further configuration. To avoid runtime initialization, call\n `tf.config.list_physical_devices` instead.\n\n For example:\n\n >>> logical_devices = tf.config.list_logical_devices('GPU')\n >>> if len(logical_devices) > 0:\n ... # Allocate on GPU:0\n ... with tf.device(logical_devices[0].name):\n ... one = tf.constant(1)\n ... # Allocate on GPU:1\n ... with tf.device(logical_devices[1].name):\n ... two = tf.constant(2)\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of initialized `LogicalDevice`s\n ", "desc": "Return a list of logical devices created by runtime.", "type": "API"}, {"name": "tf.compat.v1.config.list_physical_devices", "docs": "Return a list of physical devices visible to the host runtime.\n\n Physical devices are hardware devices present on the host machine. By default\n all discovered CPU and GPU devices are considered visible.\n\n This API allows querying the physical hardware resources prior to runtime\n initialization. Thus, giving an opportunity to call any additional\n configuration APIs. This is in contrast to `tf.config.list_logical_devices`,\n which triggers runtime initialization in order to list the configured devices.\n\n The following example lists the number of visible GPUs on the host.\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> print(\"Num GPUs:\", len(physical_devices))\n Num GPUs: ...\n\n However, the number of GPUs available to the runtime may change during runtime\n initialization due to marking certain devices as not visible or configuring\n multiple logical devices.\n\n Args:\n device_type: (optional string) Only include devices matching this device\n type. For example \"CPU\" or \"GPU\".\n\n Returns:\n List of discovered `tf.config.PhysicalDevice` objects\n ", "desc": "Return a list of physical devices visible to the host runtime.", "type": "API"}, {"name": "tf.compat.v1.config.LogicalDevice", "docs": "Abstraction for a logical device initialized by the runtime.\n\n A `tf.config.LogicalDevice` corresponds to an initialized logical device on a\n `tf.config.PhysicalDevice` or a remote device visible to the cluster. Tensors\n and operations can be placed on a specific logical device by calling\n `tf.device` with a specified `tf.config.LogicalDevice`.\n\n Fields:\n name: The fully qualified name of the device. Can be used for Op or function\n placement.\n device_type: String declaring the type of device such as \"CPU\" or \"GPU\".\n ", "desc": "Abstraction for a logical device initialized by the runtime.", "type": "API"}, {"name": "tf.compat.v1.config.LogicalDeviceConfiguration", "docs": "Configuration class for a logical devices.\n\n The class specifies the parameters to configure a `tf.config.PhysicalDevice`\n as it is initialized to a `tf.config.LogicalDevice` during runtime\n initialization. Not all fields are valid for all device types.\n\n See `tf.config.get_logical_device_configuration` and\n `tf.config.set_logical_device_configuration` for usage examples.\n\n Fields:\n memory_limit: (optional) Maximum memory (in MB) to allocate on the virtual\n device. Currently only supported for GPUs.\n experimental_priority: (optional) Priority to assign to a virtual device.\n Lower values have higher priorities and 0 is the default.\n Within a physical GPU, the GPU scheduler will prioritize ops on virtual\n devices with higher priority. Currently only supported for Nvidia GPUs.\n ", "desc": "Configuration class for a logical devices.", "type": "API"}, {"name": "tf.compat.v1.config.optimizer", "docs": "Public API for tf.config.optimizer namespace.\n", "desc": "Public API for tf.config.optimizer namespace.", "type": "API"}, {"name": "tf.compat.v1.config.optimizer.get_experimental_options", "docs": "Get experimental optimizer options.\n\n Refer to tf.config.optimizer.set_experimental_options for a list of current\n options.\n\n Note that optimizations are only applied in graph mode, (within tf.function).\n In addition, as these are experimental options, the list is subject to change.\n\n Returns:\n Dictionary of configured experimental optimizer options\n ", "desc": "Get experimental optimizer options.", "type": "API"}, {"name": "tf.compat.v1.config.optimizer.get_jit", "docs": "Returns JIT compilation configuration for code inside `tf.function`.\n\n Possible return values:\n -`\"autoclustering\"` if\n [autoclustering](https://www.tensorflow.org/xla#auto-clustering) is enabled\n - `\"\"` when no default compilation is applied.\n ", "desc": "Returns JIT compilation configuration for code inside `tf.function`.", "type": "API"}, {"name": "tf.compat.v1.config.optimizer.set_experimental_options", "docs": "Set experimental optimizer options.\n\n Note that optimizations are only applied in graph mode, (within tf.function).\n In addition, as these are experimental options, the list is subject to change.\n\n Args:\n options: Dictionary of experimental optimizer options to configure.\n Valid keys:\n - layout_optimizer: Optimize tensor layouts e.g. This will try to use NCHW\n layout on GPU which is faster.\n - constant_folding: Fold constants Statically infer the value of tensors\n when possible, and materialize the result using constants.\n - shape_optimization: Simplify computations made on shapes.\n - remapping: Remap subgraphs onto more efficient implementations.\n - arithmetic_optimization: Simplify arithmetic ops with common\n sub-expression elimination and arithmetic simplification.\n - dependency_optimization: Control dependency optimizations. Remove\n redundant control dependencies, which may enable other optimization.\n This optimizer is also essential for pruning Identity and NoOp nodes.\n - loop_optimization: Loop optimizations.\n - function_optimization: Function optimizations and inlining.\n - debug_stripper: Strips debug-related nodes from the graph.\n - disable_model_pruning: Disable removal of unnecessary ops from the graph\n - scoped_allocator_optimization: Try to allocate some independent Op\n outputs contiguously in order to merge or eliminate downstream Ops.\n - pin_to_host_optimization: Force small ops onto the CPU.\n - implementation_selector: Enable the swap of kernel implementations based\n on the device placement.\n - auto_mixed_precision: Change certain float32 ops to float16 on Volta\n GPUs and above. Without the use of loss scaling, this can cause\n numerical underflow (see\n `keras.mixed_precision.experimental.LossScaleOptimizer`).\n - disable_meta_optimizer: Disable the entire meta optimizer.\n - min_graph_nodes: The minimum number of nodes in a graph to optimizer.\n For smaller graphs, optimization is skipped.\n ", "desc": "Set experimental optimizer options.", "type": "API"}, {"name": "tf.compat.v1.config.optimizer.set_jit", "docs": "Configure JIT compilation. (deprecated argument values)\n\nDeprecated: SOME ARGUMENT VALUES ARE DEPRECATED: `(jit_config=True)`. They will be removed in a future version.\nInstructions for updating:\n`True` setting is deprecated, use `autoclustering` instead.\n\nNote: compilation is only applied to code that is compiled into a\ngraph (in TF2 that's only a code inside `tf.function`).\n\nArgs:\n enabled: JIT compilation configuration.\n Possible values:\n - `\"autoclustering\"` (`True` is a deprecated alias): perform\n [autoclustering](https://www.tensorflow.org/xla#auto-clustering)\n (automatically identify and compile clusters of nodes) on all graphs\n using\n [XLA](https://www.tensorflow.org/xla).\n - `False`: do not automatically compile any graphs.", "desc": "Configure JIT compilation. (deprecated argument values)", "type": "API"}, {"name": "tf.compat.v1.config.PhysicalDevice", "docs": "Abstraction for a locally visible physical device.\n\n TensorFlow can utilize various devices such as the CPU or multiple GPUs\n for computation. Before initializing a local device for use, the user can\n customize certain properties of the device such as it's visibility or memory\n configuration.\n\n Once a visible `tf.config.PhysicalDevice` is initialized one or more\n `tf.config.LogicalDevice` objects are created. Use\n `tf.config.set_visible_devices` to configure the visibility of a physical\n device and `tf.config.set_logical_device_configuration` to configure multiple\n `tf.config.LogicalDevice` objects for a `tf.config.PhysicalDevice`. This is\n useful when separation between models is needed or to simulate a multi-device\n environment.\n\n Fields:\n name: Unique identifier for device.\n device_type: String declaring the type of device such as \"CPU\" or \"GPU\".\n ", "desc": "Abstraction for a locally visible physical device.", "type": "API"}, {"name": "tf.compat.v1.config.run_functions_eagerly", "docs": "Enables / disables eager execution of `tf.function`s.\n\n Calling `tf.config.run_functions_eagerly(True)` will make all\n invocations of `tf.function` run eagerly instead of running as a traced graph\n function.\n\n This can be useful for debugging.\n\n >>> def my_func(a):\n ... print(\"Python side effect\")\n ... return a + a\n >>> a_fn = tf.function(my_func)\n\n >>> # A side effect the first time the function is traced\n >>> a_fn(tf.constant(1))\n Python side effect\n \n\n >>> # No further side effect, as the traced function is called\n >>> a_fn(tf.constant(2))\n \n\n >>> # Now, switch to eager running\n >>> tf.config.run_functions_eagerly(True)\n >>> # Side effect, as the function is called directly\n >>> a_fn(tf.constant(2))\n Python side effect\n \n\n >>> # Turn this back off\n >>> tf.config.run_functions_eagerly(False)\n\n Note: This flag has no effect on functions passed into tf.data transformations\n as arguments. tf.data functions are never executed eagerly and are always\n executed as a compiled Tensorflow Graph.\n\n Args:\n run_eagerly: Boolean. Whether to run functions eagerly.\n ", "desc": "Enables / disables eager execution of `tf.function`s.", "type": "API"}, {"name": "tf.compat.v1.config.set_logical_device_configuration", "docs": "Set the logical device configuration for a `tf.config.PhysicalDevice`.\n\n A visible `tf.config.PhysicalDevice` will by default have a single\n `tf.config.LogicalDevice` associated with it once the runtime is initialized.\n Specifying a list of `tf.config.LogicalDeviceConfiguration` objects allows\n multiple devices to be created on the same `tf.config.PhysicalDevice`.\n\n Logical device configurations can be modified by calling this function as\n long as the runtime is uninitialized. After the runtime is initialized\n calling this function raises a RuntimeError.\n\n The following example splits the CPU into 2 logical devices:\n\n >>> physical_devices = tf.config.list_physical_devices('CPU')\n >>> assert len(physical_devices) == 1, \"No CPUs found\"\n >>> # Specify 2 virtual CPUs. Note currently memory limit is not supported.\n >>> try:\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... logical_devices = tf.config.list_logical_devices('CPU')\n ... assert len(logical_devices) == 2\n ...\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration(),\n ... tf.config.LogicalDeviceConfiguration()])\n ... except:\n ... # Cannot modify logical devices once initialized.\n ... pass\n\n The following example splits the GPU into 2 logical devices with 100 MB each:\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(memory_limit=100),\n ... tf.config.LogicalDeviceConfiguration(memory_limit=100)])\n ...\n ... logical_devices = tf.config.list_logical_devices('GPU')\n ... assert len(logical_devices) == len(physical_devices) + 1\n ...\n ... tf.config.set_logical_device_configuration(\n ... physical_devices[0],\n ... [tf.config.LogicalDeviceConfiguration(memory_limit=10),\n ... tf.config.LogicalDeviceConfiguration(memory_limit=10)])\n ... except:\n ... # Invalid device or cannot modify logical devices once initialized.\n ... pass\n\n Args:\n device: The `PhysicalDevice` to configure.\n logical_devices: (optional) List of `tf.config.LogicalDeviceConfiguration`\n objects to allocate for the specified `PhysicalDevice`. If None, the\n default configuration will be used.\n\n Raises:\n ValueError: If argument validation fails.\n RuntimeError: Runtime is already initialized.\n ", "desc": "Set the logical device configuration for a `tf.config.PhysicalDevice`.", "type": "API"}, {"name": "tf.compat.v1.config.set_soft_device_placement", "docs": "Enable or disable soft device placement.\n\n If enabled, an op will be placed on CPU if any of the following are true\n 1. there's no GPU implementation for the OP\n 2. no GPU devices are known or registered\n 3. need to co-locate with reftype input(s) which are from CPU\n\n Note: by default soft device placement is enabled when running in eager mode\n (for convenience) and disabled in graph mode (for performance).\n\n Args:\n enabled: A boolean indicating whether to enable soft placement.\n ", "desc": "Enable or disable soft device placement.", "type": "API"}, {"name": "tf.compat.v1.config.set_visible_devices", "docs": "Set the list of visible devices.\n\n Specifies which `PhysicalDevice` objects are visible to the runtime.\n TensorFlow will only allocate memory and place operations on visible\n physical devices, as otherwise no `LogicalDevice` will be created on them.\n By default all discovered devices are marked as visible.\n\n The following example demonstrates disabling the first GPU on the machine.\n\n >>> physical_devices = tf.config.list_physical_devices('GPU')\n >>> try:\n ... # Disable first GPU\n ... tf.config.set_visible_devices(physical_devices[1:], 'GPU')\n ... logical_devices = tf.config.list_logical_devices('GPU')\n ... # Logical device was not created for first GPU\n ... assert len(logical_devices) == len(physical_devices) - 1\n ... except:\n ... # Invalid device or cannot modify virtual devices once initialized.\n ... pass\n\n Args:\n devices: List of `PhysicalDevice`s to make visible\n device_type: (optional) Only configure devices matching this device type.\n For example \"CPU\" or \"GPU\". Other devices will be left unaltered.\n\n Raises:\n ValueError: If argument validation fails.\n RuntimeError: Runtime is already initialized.\n ", "desc": "Set the list of visible devices.", "type": "API"}, {"name": "tf.compat.v1.config.threading", "docs": "Public API for tf.config.threading namespace.\n", "desc": "Public API for tf.config.threading namespace.", "type": "API"}, {"name": "tf.compat.v1.config.threading.get_inter_op_parallelism_threads", "docs": "Get number of threads used for parallelism between independent operations.\n\n Determines the number of threads used by independent non-blocking operations.\n 0 means the system picks an appropriate number.\n\n Returns:\n Number of parallel threads\n ", "desc": "Get number of threads used for parallelism between independent operations.", "type": "API"}, {"name": "tf.compat.v1.config.threading.get_intra_op_parallelism_threads", "docs": "Get number of threads used within an individual op for parallelism.\n\n Certain operations like matrix multiplication and reductions can utilize\n parallel threads for speed ups. A value of 0 means the system picks an\n appropriate number.\n\n Returns:\n Number of parallel threads\n ", "desc": "Get number of threads used within an individual op for parallelism.", "type": "API"}, {"name": "tf.compat.v1.config.threading.set_inter_op_parallelism_threads", "docs": "Set number of threads used for parallelism between independent operations.\n\n Determines the number of threads used by independent non-blocking operations.\n 0 means the system picks an appropriate number.\n\n Args:\n num_threads: Number of parallel threads\n ", "desc": "Set number of threads used for parallelism between independent operations.", "type": "API"}, {"name": "tf.compat.v1.config.threading.set_intra_op_parallelism_threads", "docs": "Set number of threads used within an individual op for parallelism.\n\n Certain operations like matrix multiplication and reductions can utilize\n parallel threads for speed ups. A value of 0 means the system picks an\n appropriate number.\n\n Args:\n num_threads: Number of parallel threads\n ", "desc": "Set number of threads used within an individual op for parallelism.", "type": "API"}, {"name": "tf.compat.v1.ConfigProto", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.ConfigProto.DeviceCountEntry", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.ConfigProto.Experimental", "docs": "", "desc": "", "type": "API"}, {"name": "tf.compat.v1.confusion_matrix", "docs": "Computes the confusion matrix from predictions and labels.\n\n The matrix columns represent the prediction labels and the rows represent the\n real labels. The confusion matrix is always a 2-D array of shape `[n, n]`,\n where `n` is the number of valid labels for a given classification task. Both\n prediction and labels must be 1-D arrays of the same shape in order for this\n function to work.\n\n If `num_classes` is `None`, then `num_classes` will be set to one plus the\n maximum value in either predictions or labels. Class labels are expected to\n start at 0. For example, if `num_classes` is 3, then the possible labels\n would be `[0, 1, 2]`.\n\n If `weights` is not `None`, then each prediction contributes its\n corresponding weight to the total value of the confusion matrix cell.\n\n For example:\n\n ```python\n tf.math.confusion_matrix([1, 2, 4], [2, 2, 4]) ==>\n [[0 0 0 0 0]\n [0 0 1 0 0]\n [0 0 1 0 0]\n [0 0 0 0 0]\n [0 0 0 0 1]]\n ```\n\n Note that the possible labels are assumed to be `[0, 1, 2, 3, 4]`,\n resulting in a 5x5 confusion matrix.\n\n Args:\n labels: 1-D `Tensor` of real labels for the classification task.\n predictions: 1-D `Tensor` of predictions for a given classification.\n num_classes: The possible number of labels the classification task can have.\n If this value is not provided, it will be calculated using both\n predictions and labels array.\n dtype: Data type of the confusion matrix.\n name: Scope name.\n weights: An optional `Tensor` whose shape matches `predictions`.\n\n Returns:\n A `Tensor` of type `dtype` with shape `[n, n]` representing the confusion\n matrix, where `n` is the number of possible labels in the classification\n task.\n\n Raises:\n ValueError: If both predictions and labels are not 1-D vectors and have\n mismatched shapes, or if `weights` is not `None` and its shape doesn't\n match `predictions`.\n ", "desc": "Computes the confusion matrix from predictions and labels.", "type": "API"}, {"name": "tf.compat.v1.conj", "docs": "Returns the complex conjugate of a complex number.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `x`. The\n complex numbers in `x` must be of the form \\\\(a + bj\\\\), where `a` is the\n real part and `b` is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n >>> x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n >>> tf.math.conj(x)\n \n\n If `x` is real, it is returned unchanged.\n\n For example:\n\n >>> x = tf.constant([-2.25, 3.25])\n >>> tf.math.conj(x)\n \n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n\n @compatibility(numpy)\n Equivalent to numpy.conj.\n @end_compatibility\n ", "desc": "Returns the complex conjugate of a complex number.", "type": "API"}, {"name": "tf.compat.v1.constant", "docs": "Creates a constant tensor.\n\n The resulting tensor is populated with values of type `dtype`, as\n specified by arguments `value` and (optionally) `shape` (see examples\n below).\n\n The argument `value` can be a constant value, or a list of values of type\n `dtype`. If `value` is a list, then the length of the list must be less\n than or equal to the number of elements implied by the `shape` argument (if\n specified). In the case where the list length is less than the number of\n elements specified by `shape`, the last element in the list will be used\n to fill the remaining entries.\n\n The argument `shape` is optional. If present, it specifies the dimensions of\n the resulting tensor. If not present, the shape of `value` is used.\n\n If the argument `dtype` is not specified, then the type is inferred from\n the type of `value`.\n\n For example:\n\n ```python\n # Constant 1-D Tensor populated with value list.\n tensor = tf.constant([1, 2, 3, 4, 5, 6, 7]) => [1 2 3 4 5 6 7]\n\n # Constant 2-D tensor populated with scalar value -1.\n tensor = tf.constant(-1.0, shape=[2, 3]) => [[-1. -1. -1.]\n [-1. -1. -1.]]\n ```\n\n `tf.constant` differs from `tf.fill` in a few ways:\n\n * `tf.constant` supports arbitrary constants, not just uniform scalar\n Tensors like `tf.fill`.\n * `tf.constant` creates a `Const` node in the computation graph with the\n exact value at graph construction time. On the other hand, `tf.fill`\n creates an Op in the graph that is expanded at runtime.\n * Because `tf.constant` only embeds constant values in the graph, it does\n not support dynamic shapes based on other runtime Tensors, whereas\n `tf.fill` does.\n\n Args:\n value: A constant value (or list) of output type `dtype`.\n\n dtype: The type of the elements of the resulting tensor.\n\n shape: Optional dimensions of resulting tensor.\n\n name: Optional name for the tensor.\n\n verify_shape: Boolean that enables verification of a shape of values.\n\n Returns:\n A Constant Tensor.\n\n Raises:\n TypeError: if shape is incorrectly specified or unsupported.\n ", "desc": "Creates a constant tensor.", "type": "API"}, {"name": "tf.compat.v1.constant_initializer", "docs": "Initializer that generates tensors with constant values.\n\n The resulting tensor is populated with values of type `dtype`, as\n specified by arguments `value` following the desired `shape` of the\n new tensor (see examples below).\n\n The argument `value` can be a constant value, or a list of values of type\n `dtype`. If `value` is a list, then the length of the list must be less\n than or equal to the number of elements implied by the desired shape of the\n tensor. In the case where the total number of elements in `value` is less\n than the number of elements required by the tensor shape, the last element\n in `value` will be used to fill the remaining entries. If the total number of\n elements in `value` is greater than the number of elements required by the\n tensor shape, the initializer will raise a `ValueError`.\n\n Args:\n value: A Python scalar, list or tuple of values, or a N-dimensional numpy\n array. All elements of the initialized variable will be set to the\n corresponding value in the `value` argument.\n dtype: Default data type, used if no `dtype` argument is provided when\n calling the initializer.\n verify_shape: Boolean that enables verification of the shape of `value`. If\n `True`, the initializer will throw an error if the shape of `value` is not\n compatible with the shape of the initialized tensor.\n\n Raises:\n TypeError: If the input `value` is not one of the expected types.\n\n Examples:\n The following example can be rewritten using a numpy.ndarray instead\n of the `value` list, even reshaped, as shown in the two commented lines\n below the `value` list initialization.\n\n >>> value = [0, 1, 2, 3, 4, 5, 6, 7]\n >>> init = tf.compat.v1.constant_initializer(value)\n >>> # fitting shape\n >>> with tf.compat.v1.Session():\n ... x = tf.compat.v1.get_variable('x', shape=[2, 4], initializer=init)\n ... x.initializer.run()\n ... print(x.eval())\n [[0. 1. 2. 3.]\n [4. 5. 6. 7.]]\n >>> # Larger shape\n >>> with tf.compat.v1.Session():\n ... y = tf.compat.v1.get_variable('y', shape=[3, 4], initializer=init)\n ... y.initializer.run()\n ... print(y.eval())\n [[0. 1. 2. 3.]\n [4. 5. 6. 7.]\n [7. 7. 7. 7.]]\n >>> # Smaller shape\n >>> with tf.compat.v1.Session():\n ... z = tf.compat.v1.get_variable('z', shape=[2, 3], initializer=init)\n Traceback (most recent call last):\n ...\n ValueError: Too many elements provided. Needed at most 6, but received 8\n >>> # Shape verification\n >>> init_verify = tf.compat.v1.constant_initializer(value, verify_shape=True)\n >>> with tf.compat.v1.Session():\n ... u = tf.compat.v1.get_variable('u', shape=[3, 4],\n ... initializer=init_verify)\n Traceback (most recent call last):\n ...\n TypeError: Expected Tensor's shape: (3, 4), got (8,).\n\n @compatibility(TF2)\n Although it is a legacy API endpoint, `tf.compat.v1.constant_initializer`\n is compatible with eager execution and `tf.function`.\n\n To migrate to a non-legacy TF2 API, please use `tf.constant_initializer`\n instead. The `dtype`\n argument in `tf.compat.v1.constant_initializer.__init__()` does not exist in\n `tf.constant_initializer.__init__()`. However, you can specify the `dtype` in\n `__call__()` in both cases.\n\n In the `compat.v1` symbol, if `verify_shape` is set to `True`, an exception\n is raised when initializing a variable with a different shape from\n `value`. If set to `False`, `value` is reshaped to initialize the variable\n if necessary. An exception would only be raised when the number of\n elements are different.\n\n The `verify_shape` argument is not supported in TF2. Using\n `tf.constant_initializer` is equivalent to setting `verify_shape` to `False`.\n\n #### Structural Mapping to TF2\n\n Before:\n\n ```python\n value = [0, 1, 2, 3, 4, 5, 6, 7]\n initializer = tf.compat.v1.constant_initializer(\n value=value,\n dtype=tf.float32,\n verify_shape=False)\n variable = tf.Variable(initializer(shape=[2, 4]))\n ```\n\n After:\n\n ```python\n value = [0, 1, 2, 3, 4, 5, 6, 7]\n initializer = tf.constant_initializer(value=value)\n tf.Variable(initializer(shape=[2, 4], dtype=tf.float32))\n ```\n\n #### How to Map Arguments\n\n | TF1 Arg Name | TF2 Arg Name | Note |\n | :-------------------- | :--------------- | :-------------------------- |\n | `value` | `value` | In constructor |\n | `dtype` | `dtype` | In `__call__()` method |\n | `verify_shape` | Not Supported | Equivalent to set to `False`|\n | `partition_info` | - | (`__call__` arg in TF1) Not supported |\n\n\n #### Before & After Usage Example\n\n Before:\n\n >>> value = [1., 2., 3., 4.]\n >>> initializer = tf.compat.v1.constant_initializer(\n ... value=value, dtype=tf.float32, verify_shape=True)\n >>> tf.Variable(initializer(shape=[2, 2])).numpy()\n Traceback (most recent call last):\n ...\n TypeError: Expected Tensor's shape: (2, 2), got (4,).\n >>> initializer = tf.compat.v1.constant_initializer(\n ... value=value, dtype=tf.float32, verify_shape=False)\n >>> tf.Variable(initializer(shape=[2, 2])).numpy()\n array([[1., 2.],\n [3., 4.]], dtype=float32)\n\n After:\n\n >>> value = [1., 2., 3., 4.]\n >>> initializer = tf.constant_initializer(value=value)\n >>> tf.Variable(initializer(shape=[2, 2], dtype=tf.float32)).numpy()\n array([[1., 2.],\n [3., 4.]], dtype=float32)\n\n @end_compatibility\n ", "desc": "Initializer that generates tensors with constant values.", "type": "API"}, {"name": "tf.compat.v1.container", "docs": "Wrapper for `Graph.container()` using the default graph.\n\n Args:\n container_name: The container string to use in the context.\n\n Returns:\n A context manager that specifies the default container to use for newly\n created stateful ops.\n ", "desc": "Wrapper for `Graph.container()` using the default graph.", "type": "API"}, {"name": "tf.compat.v1.control_dependencies", "docs": "Wrapper for `Graph.control_dependencies()` using the default graph.\n\n See `tf.Graph.control_dependencies` for more details.\n\n Note: *In TensorFlow 2 with eager and/or Autograph, you should not require\n this method, as ops execute in the expected order thanks to automatic control\n dependencies.* Only use `tf.control_dependencies` when working with v1\n `tf.Graph` code.\n\n When eager execution is enabled, any callable object in the `control_inputs`\n list will be called.\n\n Args:\n control_inputs: A list of `Operation` or `Tensor` objects which must be\n executed or computed before running the operations defined in the context.\n Can also be `None` to clear the control dependencies. If eager execution\n is enabled, any callable object in the `control_inputs` list will be\n called.\n\n Returns:\n A context manager that specifies control dependencies for all\n operations constructed within the context.\n ", "desc": "Wrapper for `Graph.control_dependencies()` using the default graph.", "type": "API"}, {"name": "tf.compat.v1.control_flow_v2_enabled", "docs": "Returns `True` if v2 control flow is enabled.\n\n Note: v2 control flow is always enabled inside of tf.function.\n ", "desc": "Returns `True` if v2 control flow is enabled.", "type": "API"}, {"name": "tf.compat.v1.convert_to_tensor", "docs": "Converts the given `value` to a `Tensor`.\n\n This function converts Python objects of various types to `Tensor`\n objects. It accepts `Tensor` objects, numpy arrays, Python lists,\n and Python scalars. For example:\n\n ```python\n import numpy as np\n\n def my_func(arg):\n arg = tf.convert_to_tensor(arg, dtype=tf.float32)\n return tf.matmul(arg, arg) + arg\n\n # The following calls are equivalent.\n value_1 = my_func(tf.constant([[1.0, 2.0], [3.0, 4.0]]))\n value_2 = my_func([[1.0, 2.0], [3.0, 4.0]])\n value_3 = my_func(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32))\n ```\n\n This function can be useful when composing a new operation in Python\n (such as `my_func` in the example above). All standard Python op\n constructors apply this function to each of their Tensor-valued\n inputs, which allows those ops to accept numpy arrays, Python lists,\n and scalars in addition to `Tensor` objects.\n\n Note: This function diverges from default Numpy behavior for `float` and\n `string` types when `None` is present in a Python list or scalar. Rather\n than silently converting `None` values, an error will be thrown.\n\n Args:\n value: An object whose type has a registered `Tensor` conversion function.\n dtype: Optional element type for the returned tensor. If missing, the type\n is inferred from the type of `value`.\n name: Optional name to use if a new `Tensor` is created.\n preferred_dtype: Optional element type for the returned tensor, used when\n dtype is None. In some cases, a caller may not have a dtype in mind when\n converting to a tensor, so preferred_dtype can be used as a soft\n preference. If the conversion to `preferred_dtype` is not possible, this\n argument has no effect.\n dtype_hint: same meaning as preferred_dtype, and overrides it.\n\n Returns:\n A `Tensor` based on `value`.\n\n Raises:\n TypeError: If no conversion function is registered for `value` to `dtype`.\n RuntimeError: If a registered conversion function returns an invalid value.\n ValueError: If the `value` is a tensor not of given `dtype` in graph mode.\n ", "desc": "Converts the given `value` to a `Tensor`.", "type": "API"}, {"name": "tf.compat.v1.convert_to_tensor_or_indexed_slices", "docs": "Converts the given object to a `Tensor` or an `IndexedSlices`.\n\n If `value` is an `IndexedSlices` or `SparseTensor` it is returned\n unmodified. Otherwise, it is converted to a `Tensor` using\n `convert_to_tensor()`.\n\n Args:\n value: An `IndexedSlices`, `SparseTensor`, or an object that can be consumed\n by `convert_to_tensor()`.\n dtype: (Optional.) The required `DType` of the returned `Tensor` or\n `IndexedSlices`.\n name: (Optional.) A name to use if a new `Tensor` is created.\n\n Returns:\n A `Tensor`, `IndexedSlices`, or `SparseTensor` based on `value`.\n\n Raises:\n ValueError: If `dtype` does not match the element type of `value`.\n ", "desc": "Converts the given object to a `Tensor` or an `IndexedSlices`.", "type": "API"}, {"name": "tf.compat.v1.convert_to_tensor_or_sparse_tensor", "docs": "Converts value to a `SparseTensor` or `Tensor`.\n\n Args:\n value: A `SparseTensor`, `SparseTensorValue`, or an object whose type has a\n registered `Tensor` conversion function.\n dtype: Optional element type for the returned tensor. If missing, the type\n is inferred from the type of `value`.\n name: Optional name to use if a new `Tensor` is created.\n\n Returns:\n A `SparseTensor` or `Tensor` based on `value`.\n\n Raises:\n RuntimeError: If result type is incompatible with `dtype`.\n ", "desc": "Converts value to a `SparseTensor` or `Tensor`.", "type": "API"}, {"name": "tf.compat.v1.cos", "docs": "Computes cos of x element-wise.\n\n Given an input tensor, this function computes cosine of every\n element in the tensor. Input range is `(-inf, inf)` and\n output range is `[-1,1]`. If input lies outside the boundary, `nan`\n is returned.\n\n ```python\n x = tf.constant([-float(\"inf\"), -9, -0.5, 1, 1.2, 200, 10000, float(\"inf\")])\n tf.math.cos(x) ==> [nan -0.91113025 0.87758255 0.5403023 0.36235774 0.48718765 -0.95215535 nan]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes cos of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.cosh", "docs": "Computes hyperbolic cosine of x element-wise.\n\n Given an input tensor, this function computes hyperbolic cosine of every\n element in the tensor. Input range is `[-inf, inf]` and output range\n is `[1, inf]`.\n\n ```python\n x = tf.constant([-float(\"inf\"), -9, -0.5, 1, 1.2, 2, 10, float(\"inf\")])\n tf.math.cosh(x) ==> [inf 4.0515420e+03 1.1276259e+00 1.5430807e+00 1.8106556e+00 3.7621956e+00 1.1013233e+04 inf]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes hyperbolic cosine of x element-wise.", "type": "API"}, {"name": "tf.compat.v1.count_nonzero", "docs": "Computes number of nonzero elements across dimensions of a tensor. (deprecated arguments) (deprecated arguments)\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(keep_dims)`. They will be removed in a future version.\nInstructions for updating:\nkeep_dims is deprecated, use keepdims instead\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(reduction_indices)`. They will be removed in a future version.\nInstructions for updating:\nreduction_indices is deprecated, use axis instead\n\nReduces `input_tensor` along the dimensions given in `axis`.\nUnless `keepdims` is true, the rank of the tensor is reduced by 1 for each\nentry in `axis`. If `keepdims` is true, the reduced dimensions\nare retained with length 1.\n\nIf `axis` has no entries, all dimensions are reduced, and a\ntensor with a single element is returned.\n\n**NOTE** Floating point comparison to zero is done by exact floating point\nequality check. Small values are **not** rounded to zero for purposes of\nthe nonzero check.\n\nFor example:\n\n```python\nx = tf.constant([[0, 1, 0], [1, 1, 0]])\ntf.math.count_nonzero(x) # 3\ntf.math.count_nonzero(x, 0) # [1, 2, 0]\ntf.math.count_nonzero(x, 1) # [1, 2]\ntf.math.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\ntf.math.count_nonzero(x, [0, 1]) # 3\n```\n\n**NOTE** Strings are compared against zero-length empty string `\"\"`. Any\nstring with a size greater than zero is already considered as nonzero.\n\nFor example:\n```python\nx = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\ntf.math.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n```\n\nArgs:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`, or\n `string`.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n input: Overrides input_tensor. For compatibility.\n\nReturns:\n The reduced tensor (number of nonzero values).", "desc": "Computes number of nonzero elements across dimensions of a tensor. (deprecated arguments) (deprecated arguments)", "type": "API"}, {"name": "tf.compat.v1.count_up_to", "docs": "Increments 'ref' until it reaches 'limit'. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nPrefer Dataset.range instead.\n\nArgs:\n ref: A Variable. Must be one of the following types: `int32`, `int64`.\n Should be from a scalar `Variable` node.\n limit: An `int`.\n If incrementing ref would bring it above limit, instead generates an\n 'OutOfRange' error.\n name: A name for the operation (optional).\n\nReturns:\n A `Tensor`. Has the same type as `ref`.\n A copy of the input before increment. If nothing else modifies the\n input, the values produced will all be distinct.", "desc": "Increments 'ref' until it reaches 'limit'. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.create_partitioned_variables", "docs": "Create a list of partitioned variables according to the given `slicing`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.get_variable` with a partitioner set.\n\nCurrently only one dimension of the full variable can be sliced, and the\nfull variable can be reconstructed by the concatenation of the returned\nlist along that dimension.\n\nArgs:\n shape: List of integers. The shape of the full variable.\n slicing: List of integers. How to partition the variable.\n Must be of the same length as `shape`. Each value\n indicate how many slices to create in the corresponding\n dimension. Presently only one of the values can be more than 1;\n that is, the variable can only be sliced along one dimension.\n\n For convenience, The requested number of partitions does not have to\n divide the corresponding dimension evenly. If it does not, the\n shapes of the partitions are incremented by 1 starting from partition\n 0 until all slack is absorbed. The adjustment rules may change in the\n future, but as you can save/restore these variables with different\n slicing specifications this should not be a problem.\n initializer: A `Tensor` of shape `shape` or a variable initializer\n function. If a function, it will be called once for each slice,\n passing the shape and data type of the slice as parameters. The\n function must return a tensor with the same shape as the slice.\n dtype: Type of the variables. Ignored if `initializer` is a `Tensor`.\n trainable: If True also add all the variables to the graph collection\n `GraphKeys.TRAINABLE_VARIABLES`.\n collections: List of graph collections keys to add the variables to.\n Defaults to `[GraphKeys.GLOBAL_VARIABLES]`.\n name: Optional name for the full variable. Defaults to\n `\"PartitionedVariable\"` and gets uniquified automatically.\n reuse: Boolean or `None`; if `True` and name is set, it would reuse\n previously created variables. if `False` it will create new variables.\n if `None`, it would inherit the parent scope reuse.\n\nReturns:\n A list of Variables corresponding to the slicing.\n\nRaises:\n ValueError: If any of the arguments is malformed.", "desc": "Create a list of partitioned variables according to the given `slicing`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.CriticalSection", "docs": "Critical section.\n\n A `CriticalSection` object is a resource in the graph which executes subgraphs\n in **serial** order. A common example of a subgraph one may wish to run\n exclusively is the one given by the following function:\n\n ```python\n v = resource_variable_ops.ResourceVariable(0.0, name=\"v\")\n\n def count():\n value = v.read_value()\n with tf.control_dependencies([value]):\n with tf.control_dependencies([v.assign_add(1)]):\n return tf.identity(value)\n ```\n\n Here, a snapshot of `v` is captured in `value`; and then `v` is updated.\n The snapshot value is returned.\n\n If multiple workers or threads all execute `count` in parallel, there is no\n guarantee that access to the variable `v` is atomic at any point within\n any thread's calculation of `count`. In fact, even implementing an atomic\n counter that guarantees that the user will see each value `0, 1, ...,` is\n currently impossible.\n\n The solution is to ensure any access to the underlying resource `v` is\n only processed through a critical section:\n\n ```python\n cs = CriticalSection()\n f1 = cs.execute(count)\n f2 = cs.execute(count)\n output = f1 + f2\n session.run(output)\n ```\n The functions `f1` and `f2` will be executed serially, and updates to `v`\n will be atomic.\n\n **NOTES**\n\n All resource objects, including the critical section and any captured\n variables of functions executed on that critical section, will be\n colocated to the same device (host and cpu/gpu).\n\n When using multiple critical sections on the same resources, there is no\n guarantee of exclusive access to those resources. This behavior is disallowed\n by default (but see the kwarg `exclusive_resource_access`).\n\n For example, running the same function in two separate critical sections\n will not ensure serial execution:\n\n ```python\n v = tf.compat.v1.get_variable(\"v\", initializer=0.0, use_resource=True)\n def accumulate(up):\n x = v.read_value()\n with tf.control_dependencies([x]):\n with tf.control_dependencies([v.assign_add(up)]):\n return tf.identity(x)\n ex1 = CriticalSection().execute(\n accumulate, 1.0, exclusive_resource_access=False)\n ex2 = CriticalSection().execute(\n accumulate, 1.0, exclusive_resource_access=False)\n bad_sum = ex1 + ex2\n sess.run(v.initializer)\n sess.run(bad_sum) # May return 0.0\n ```\n ", "desc": "Critical section.", "type": "API"}, {"name": "tf.compat.v1.cross", "docs": "Compute the pairwise cross product.\n\n `a` and `b` must be the same shape; they can either be simple 3-element vectors,\n or any shape where the innermost dimension is 3. In the latter case, each pair\n of corresponding 3-element vectors is cross-multiplied independently.\n\n Args:\n a: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`.\n A tensor containing 3-element vectors.\n b: A `Tensor`. Must have the same type as `a`.\n Another tensor, of same type and shape as `a`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `a`.\n ", "desc": "Compute the pairwise cross product.", "type": "API"}, {"name": "tf.compat.v1.cumprod", "docs": "Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Compute the cumulative product of the tensor `x` along `axis`.", "type": "API"}, {"name": "tf.compat.v1.cumsum", "docs": "Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n For example:\n\n >>> # tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n >>> x = tf.constant([2, 4, 6, 8])\n >>> tf.cumsum(x)\n \n\n >>> # using varying `axis` values\n >>> y = tf.constant([[2, 4, 6, 8], [1,3,5,7]])\n >>> tf.cumsum(y, axis=0)\n \n >>> tf.cumsum(y, axis=1)\n \n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n >>> # tf.cumsum([a, b, c], exclusive=True) => [0, a, a + b]\n >>> x = tf.constant([2, 4, 6, 8])\n >>> tf.cumsum(x, exclusive=True)\n \n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n >>> # tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n >>> x = tf.constant([2, 4, 6, 8])\n >>> tf.cumsum(x, reverse=True)\n \n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n >>> # tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n >>> x = tf.constant([2, 4, 6, 8])\n >>> tf.cumsum(x, exclusive=True, reverse=True)\n \n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Compute the cumulative sum of the tensor `x` along `axis`.", "type": "API"}, {"name": "tf.compat.v1.custom_gradient", "docs": "Decorator to define a function with a custom gradient.\n\n This decorator allows fine grained control over the gradients of a sequence\n for operations. This may be useful for multiple reasons, including providing\n a more efficient or numerically stable gradient for a sequence of operations.\n\n For example, consider the following function that commonly occurs in the\n computation of cross entropy and log likelihoods:\n\n ```python\n def log1pexp(x):\n return tf.math.log(1 + tf.exp(x))\n ```\n\n Due to numerical instability, the gradient of this function evaluated at x=100\n is NaN. For example:\n\n ```python\n x = tf.constant(100.)\n y = log1pexp(x)\n dy_dx = tf.gradients(y, x) # Will be NaN when evaluated.\n ```\n\n The gradient expression can be analytically simplified to provide numerical\n stability:\n\n ```python\n @tf.custom_gradient\n def log1pexp(x):\n e = tf.exp(x)\n def grad(upstream):\n return upstream * (1 - 1 / (1 + e))\n return tf.math.log(1 + e), grad\n ```\n\n With this definition, the gradient `dy_dx` at `x = 100` will be correctly\n evaluated as 1.0.\n\n The variable `upstream` is defined as the upstream gradient. i.e. the gradient\n from all the layers or functions originating from this layer. The above\n example has no upstream functions, therefore `upstream = dy/dy = 1.0`.\n\n Assume that `x_i` is `log1pexp` in the forward pass `x_1 = x_1(x_0)`,\n `x_2 = x_2(x_1)`, ..., `x_i = x_i(x_i-1)`, ..., `x_n = x_n(x_n-1)`. By\n chain rule we know that `dx_n/dx_0 = dx_n/dx_n-1 * dx_n-1/dx_n-2 * ... *\n dx_i/dx_i-1 * ... * dx_1/dx_0`.\n\n In this case the gradient of our current function defined as\n `dx_i/dx_i-1 = (1 - 1 / (1 + e))`. The upstream gradient `upstream` would be\n `dx_n/dx_n-1 * dx_n-1/dx_n-2 * ... * dx_i+1/dx_i`. The upstream gradient\n multiplied by the current gradient is then passed downstream.\n\n In case the function takes multiple variables as input, the `grad`\n function must also return the same number of variables.\n We take the function `z = x * y` as an example.\n\n >>> @tf.custom_gradient\n ... def bar(x, y):\n ... def grad(upstream):\n ... dz_dx = y\n ... dz_dy = x\n ... return upstream * dz_dx, upstream * dz_dy\n ... z = x * y\n ... return z, grad\n >>> x = tf.constant(2.0, dtype=tf.float32)\n >>> y = tf.constant(3.0, dtype=tf.float32)\n >>> with tf.GradientTape(persistent=True) as tape:\n ... tape.watch(x)\n ... tape.watch(y)\n ... z = bar(x, y)\n >>> z\n \n >>> tape.gradient(z, x)\n \n >>> tape.gradient(z, y)\n \n\n Nesting custom gradients can lead to unintuitive results. The default\n behavior does not correspond to n-th order derivatives. For example\n\n ```python\n @tf.custom_gradient\n def op(x):\n y = op1(x)\n @tf.custom_gradient\n def grad_fn(dy):\n gdy = op2(x, y, dy)\n def grad_grad_fn(ddy): # Not the 2nd order gradient of op w.r.t. x.\n return op3(x, y, dy, ddy)\n return gdy, grad_grad_fn\n return y, grad_fn\n ```\n\n The function `grad_grad_fn` will be calculating the first order gradient\n of `grad_fn` with respect to `dy`, which is used to generate forward-mode\n gradient graphs from backward-mode gradient graphs, but is not the same as\n the second order gradient of `op` with respect to `x`.\n\n Instead, wrap nested `@tf.custom_gradients` in another function:\n\n ```python\n @tf.custom_gradient\n def op_with_fused_backprop(x):\n y, x_grad = fused_op(x)\n def first_order_gradient(dy):\n @tf.custom_gradient\n def first_order_custom(unused_x):\n def second_order_and_transpose(ddy):\n return second_order_for_x(...), gradient_wrt_dy(...)\n return x_grad, second_order_and_transpose\n return dy * first_order_custom(x)\n return y, first_order_gradient\n ```\n\n Additional arguments to the inner `@tf.custom_gradient`-decorated function\n control the expected return values of the innermost function.\n\n The examples above illustrate how to specify custom gradients for functions\n which do not read from variables. The following example uses variables, which\n require special handling because they are effectively inputs of the forward\n function.\n\n >>> weights = tf.Variable(tf.ones([2])) # Trainable variable weights\n >>> @tf.custom_gradient\n ... def linear_poly(x):\n ... # Creating polynomial\n ... poly = weights[1] * x + weights[0]\n ...\n ... def grad_fn(dpoly, variables):\n ... # dy/dx = weights[1] and we need to left multiply dpoly\n ... grad_xs = dpoly * weights[1] # Scalar gradient\n ...\n ... grad_vars = [] # To store gradients of passed variables\n ... assert variables is not None\n ... assert len(variables) == 1\n ... assert variables[0] is weights\n ... # Manually computing dy/dweights\n ... dy_dw = dpoly * tf.stack([x ** 1, x ** 0])\n ... grad_vars.append(\n ... tf.reduce_sum(tf.reshape(dy_dw, [2, -1]), axis=1)\n ... )\n ... return grad_xs, grad_vars\n ... return poly, grad_fn\n >>> x = tf.constant([1., 2., 3.])\n >>> with tf.GradientTape(persistent=True) as tape:\n ... tape.watch(x)\n ... poly = linear_poly(x)\n >>> poly # poly = x + 1\n \n >>> tape.gradient(poly, x) # conventional scalar gradient dy/dx\n \n >>> tape.gradient(poly, weights)\n \n\n Above example illustrates usage of trainable variable `weights`.\n In the example, the inner `grad_fn` accepts an extra `variables` input\n parameter and also returns an extra `grad_vars` output. That extra argument\n is passed if the forward function reads any variables. You need to\n compute the gradient w.r.t. each of those `variables` and output it as a list\n of `grad_vars`. Note here that default value of `variables` is set to `None`\n when no variables are used in the forward function.\n\n It should be noted `tf.GradientTape` is still watching the forward pass of a\n `tf.custom_gradient`, and will use the ops it watches. As a consequence,\n calling `tf.function` while the tape is still watching leads\n to a gradient graph being built. If an op is used in `tf.function` without\n registered gradient, a `LookupError` will be raised.\n\n Users can insert `tf.stop_gradient` to customize this behavior. This\n is demonstrated in the example below. `tf.random.shuffle` does not have a\n registered gradient. As a result `tf.stop_gradient` is used to avoid the\n `LookupError`.\n\n ```python\n x = tf.constant([0.3, 0.5], dtype=tf.float32)\n\n @tf.custom_gradient\n def test_func_with_stop_grad(x):\n @tf.function\n def _inner_func():\n # Avoid exception during the forward pass\n return tf.stop_gradient(tf.random.shuffle(x))\n # return tf.random.shuffle(x) # This will raise\n\n res = _inner_func()\n def grad(upstream):\n return upstream # Arbitrarily defined custom gradient\n return res, grad\n\n with tf.GradientTape() as g:\n g.watch(x)\n res = test_func_with_stop_grad(x)\n\n g.gradient(res, x)\n ```\n\n See also `tf.RegisterGradient` which registers a gradient function for a\n primitive TensorFlow operation. `tf.custom_gradient` on the other hand allows\n for fine grained control over the gradient computation of a sequence of\n operations.\n\n Note that if the decorated function uses `Variable`s, the enclosing variable\n scope must be using `ResourceVariable`s.\n\n Args:\n f: function `f(*x)` that returns a tuple `(y, grad_fn)` where:\n - `x` is a sequence of (nested structures of) `Tensor` inputs to the\n function.\n - `y` is a (nested structure of) `Tensor` outputs of applying TensorFlow\n operations in `f` to `x`.\n - `grad_fn` is a function with the signature `g(*grad_ys)` which returns\n a list of `Tensor`s the same size as (flattened) `x` - the derivatives\n of `Tensor`s in `y` with respect to the `Tensor`s in `x`. `grad_ys` is\n a sequence of `Tensor`s the same size as (flattened) `y` holding the\n initial value gradients for each `Tensor` in `y`.\n\n In a pure mathematical sense, a vector-argument vector-valued function\n `f`'s derivatives should be its Jacobian matrix `J`. Here we are\n expressing the Jacobian `J` as a function `grad_fn` which defines how\n `J` will transform a vector `grad_ys` when left-multiplied with it\n (`grad_ys * J`, the vector-Jacobian product, or VJP). This functional\n representation of a matrix is convenient to use for chain-rule\n calculation (in e.g. the back-propagation algorithm).\n\n If `f` uses `Variable`s (that are not part of the\n inputs), i.e. through `get_variable`, then `grad_fn` should have\n signature `g(*grad_ys, variables=None)`, where `variables` is a list of\n the `Variable`s, and return a 2-tuple `(grad_xs, grad_vars)`, where\n `grad_xs` is the same as above, and `grad_vars` is a `list`\n with the derivatives of `Tensor`s in `y` with respect to the variables\n (that is, grad_vars has one Tensor per variable in variables).\n\n Returns:\n A function `h(x)` which returns the same value as `f(x)[0]` and whose\n gradient (as calculated by `tf.gradients`) is determined by `f(x)[1]`.\n ", "desc": "Decorator to define a function with a custom gradient.", "type": "API"}, {"name": "tf.compat.v1.data", "docs": "`tf.data.Dataset` API for input pipelines.\n\nSee [Importing Data](https://tensorflow.org/guide/data) for an overview.\n\n", "desc": "`tf.data.Dataset` API for input pipelines.", "type": "API"}, {"name": "tf.compat.v1.data.Dataset", "docs": "Represents a potentially large set of elements.\n\n A `Dataset` can be used to represent an input pipeline as a\n collection of elements and a \"logical plan\" of transformations that act on\n those elements.\n ", "desc": "Represents a potentially large set of elements.", "type": "API"}, {"name": "tf.compat.v1.data.DatasetSpec", "docs": "Type specification for `tf.data.Dataset`.\n\n See `tf.TypeSpec` for more information about TensorFlow type specifications.\n\n >>> dataset = tf.data.Dataset.range(3)\n >>> tf.data.DatasetSpec.from_value(dataset)\n DatasetSpec(TensorSpec(shape=(), dtype=tf.int64, name=None), TensorShape([]))\n ", "desc": "Type specification for `tf.data.Dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental", "docs": "Experimental API for building input pipelines.\n\nThis module contains experimental `Dataset` sources and transformations that can\nbe used in conjunction with the `tf.data.Dataset` API. Note that the\n`tf.data.experimental` API is not subject to the same backwards compatibility\nguarantees as `tf.data`, but we will provide deprecation advice in advance of\nremoving existing functionality.\n\nSee [Importing Data](https://tensorflow.org/guide/datasets) for an overview.\n\n@@AutoShardPolicy\n@@AutotuneAlgorithm\n@@AutotuneOptions\n@@CheckpointInputPipelineHook\n@@Counter\n@@CsvDataset\n@@DatasetInitializer\n@@DatasetStructure\n@@DistributeOptions\n@@ExternalStatePolicy\n@@OptimizationOptions\n@@Optional\n@@OptionalStructure\n@@RaggedTensorStructure\n@@RandomDataset\n@@Reducer\n@@SparseTensorStructure\n@@SqlDataset\n@@Structure\n@@TFRecordWriter\n@@TensorArrayStructure\n@@TensorStructure\n@@ThreadingOptions\n\n@@assert_cardinality\n@@bucket_by_sequence_length\n@@cardinality\n@@choose_from_datasets\n@@copy_to_device\n@@dense_to_ragged_batch\n@@dense_to_sparse_batch\n@@distribute\n@@enable_debug_mode\n@@enumerate_dataset\n@@from_variant\n@@get_next_as_optional\n@@get_single_element\n@@get_structure\n@@group_by_reducer\n@@group_by_window\n@@ignore_errors\n@@index_table_from_dataset\n@@load\n@@make_batched_features_dataset\n@@make_csv_dataset\n@@make_saveable_from_iterator\n@@map_and_batch\n@@map_and_batch_with_legacy_function\n@@parallel_interleave\n@@parse_example_dataset\n@@prefetch_to_device\n@@rejection_resample\n@@sample_from_datasets\n@@save\n@@scan\n@@shuffle_and_repeat\n@@snapshot\n@@table_from_dataset\n@@take_while\n@@to_variant\n@@unbatch\n@@unique\n\n@@AUTOTUNE\n@@INFINITE_CARDINALITY\n@@SHARD_HINT\n@@UNKNOWN_CARDINALITY\n\n", "desc": "Experimental API for building input pipelines.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.assert_cardinality", "docs": "Asserts the cardinality of the input dataset.\n\n NOTE: The following assumes that \"examples.tfrecord\" contains 42 records.\n\n >>> dataset = tf.data.TFRecordDataset(\"examples.tfrecord\")\n >>> cardinality = tf.data.experimental.cardinality(dataset)\n >>> print((cardinality == tf.data.experimental.UNKNOWN_CARDINALITY).numpy())\n True\n >>> dataset = dataset.apply(tf.data.experimental.assert_cardinality(42))\n >>> print(tf.data.experimental.cardinality(dataset).numpy())\n 42\n\n Args:\n expected_cardinality: The expected cardinality of the input dataset.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\n Raises:\n FailedPreconditionError: The assertion is checked at runtime (when iterating\n the dataset) and an error is raised if the actual and expected cardinality\n differ.\n ", "desc": "Asserts the cardinality of the input dataset.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.AutoShardPolicy", "docs": "Represents the type of auto-sharding to use.\n\n OFF: No sharding will be performed.\n\n AUTO: Attempts FILE-based sharding, falling back to DATA-based sharding.\n\n FILE: Shards by input files (i.e. each worker will get a set of files to\n process). When this option is selected, make sure that there is at least as\n many files as workers. If there are fewer input files than workers, a runtime\n error will be raised.\n\n DATA: Shards by elements produced by the dataset. Each worker will process the\n whole dataset and discard the portion that is not for itself. Note that for\n this mode to correctly partitions the dataset elements, the dataset needs to\n produce elements in a deterministic order.\n\n HINT: Looks for the presence of `shard(SHARD_HINT, ...)` which is treated as a\n placeholder to replace with `shard(num_workers, worker_index)`.\n ", "desc": "Represents the type of auto-sharding to use.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.bucket_by_sequence_length", "docs": "A transformation that buckets elements in a `Dataset` by length. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.bucket_by_sequence_length(...)`.\n\nElements of the `Dataset` are grouped together by length and then are padded\nand batched.\n\nThis is useful for sequence tasks in which the elements have variable length.\nGrouping together elements that have similar lengths reduces the total\nfraction of padding in a batch which increases training step efficiency.\n\nBelow is an example to bucketize the input data to the 3 buckets\n\"[0, 3), [3, 5), [5, inf)\" based on sequence length, with batch size 2.\n\n>>> elements = [\n... [0], [1, 2, 3, 4], [5, 6, 7],\n... [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]\n\n>>> dataset = tf.data.Dataset.from_generator(\n... lambda: elements, tf.int64, output_shapes=[None])\n\n>>> dataset = dataset.apply(\n... tf.data.experimental.bucket_by_sequence_length(\n... element_length_func=lambda elem: tf.shape(elem)[0],\n... bucket_boundaries=[3, 5],\n... bucket_batch_sizes=[2, 2, 2]))\n\n>>> for elem in dataset.as_numpy_iterator():\n... print(elem)\n[[1 2 3 4]\n [5 6 7 0]]\n[[ 7 8 9 10 11 0]\n [13 14 15 16 19 20]]\n[[ 0 0]\n [21 22]]\n\nThere is also a possibility to pad the dataset till the bucket boundary.\nYou can also provide which value to be used while padding the data.\nBelow example uses `-1` as padding and it also shows the input data\nbeing bucketizied to two buckets \"[0,3], [4,6]\".\n\n>>> elements = [\n... [0], [1, 2, 3, 4], [5, 6, 7],\n... [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]\n\n>>> dataset = tf.data.Dataset.from_generator(\n... lambda: elements, tf.int32, output_shapes=[None])\n\n>>> dataset = dataset.apply(\n... tf.data.experimental.bucket_by_sequence_length(\n... element_length_func=lambda elem: tf.shape(elem)[0],\n... bucket_boundaries=[4, 7],\n... bucket_batch_sizes=[2, 2, 2],\n... pad_to_bucket_boundary=True,\n... padding_values=-1))\n\n>>> for elem in dataset.as_numpy_iterator():\n... print(elem)\n[[ 0 -1 -1]\n [ 5 6 7]]\n[[ 1 2 3 4 -1 -1]\n [ 7 8 9 10 11 -1]]\n[[21 22 -1]]\n[[13 14 15 16 19 20]]\n\nWhen using `pad_to_bucket_boundary` option, it can be seen that it is\nnot always possible to maintain the bucket batch size.\nYou can drop the batches that do not maintain the bucket batch size by\nusing the option `drop_remainder`. Using the same input data as in the\nabove example you get the following result.\n\n>>> elements = [\n... [0], [1, 2, 3, 4], [5, 6, 7],\n... [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]\n\n>>> dataset = tf.data.Dataset.from_generator(\n... lambda: elements, tf.int32, output_shapes=[None])\n\n>>> dataset = dataset.apply(\n... tf.data.experimental.bucket_by_sequence_length(\n... element_length_func=lambda elem: tf.shape(elem)[0],\n... bucket_boundaries=[4, 7],\n... bucket_batch_sizes=[2, 2, 2],\n... pad_to_bucket_boundary=True,\n... padding_values=-1,\n... drop_remainder=True))\n\n>>> for elem in dataset.as_numpy_iterator():\n... print(elem)\n[[ 0 -1 -1]\n [ 5 6 7]]\n[[ 1 2 3 4 -1 -1]\n [ 7 8 9 10 11 -1]]\n\nArgs:\n element_length_func: function from element in `Dataset` to `tf.int32`,\n determines the length of the element, which will determine the bucket it\n goes into.\n bucket_boundaries: `list`, upper length boundaries of the buckets.\n bucket_batch_sizes: `list`, batch size per bucket. Length should be\n `len(bucket_boundaries) + 1`.\n padded_shapes: Nested structure of `tf.TensorShape` to pass to\n `tf.data.Dataset.padded_batch`. If not provided, will use\n `dataset.output_shapes`, which will result in variable length dimensions\n being padded out to the maximum length in each batch.\n padding_values: Values to pad with, passed to\n `tf.data.Dataset.padded_batch`. Defaults to padding with 0.\n pad_to_bucket_boundary: bool, if `False`, will pad dimensions with unknown\n size to maximum length in batch. If `True`, will pad dimensions with\n unknown size to bucket boundary minus 1 (i.e., the maximum length in each\n bucket), and caller must ensure that the source `Dataset` does not contain\n any elements with length longer than `max(bucket_boundaries)`.\n no_padding: `bool`, indicates whether to pad the batch features (features\n need to be either of type `tf.sparse.SparseTensor` or of same shape).\n drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing\n whether the last batch should be dropped in the case it has fewer than\n `batch_size` elements; the default behavior is not to drop the smaller\n batch.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\nRaises:\n ValueError: if `len(bucket_batch_sizes) != len(bucket_boundaries) + 1`.", "desc": "A transformation that buckets elements in a `Dataset` by length. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.cardinality", "docs": "Returns the cardinality of `dataset`, if known.\n\n The operation returns the cardinality of `dataset`. The operation may return\n `tf.data.experimental.INFINITE_CARDINALITY` if `dataset` contains an infinite\n number of elements or `tf.data.experimental.UNKNOWN_CARDINALITY` if the\n analysis fails to determine the number of elements in `dataset` (e.g. when the\n dataset source is a file).\n\n >>> dataset = tf.data.Dataset.range(42)\n >>> print(tf.data.experimental.cardinality(dataset).numpy())\n 42\n >>> dataset = dataset.repeat()\n >>> cardinality = tf.data.experimental.cardinality(dataset)\n >>> print((cardinality == tf.data.experimental.INFINITE_CARDINALITY).numpy())\n True\n >>> dataset = dataset.filter(lambda x: True)\n >>> cardinality = tf.data.experimental.cardinality(dataset)\n >>> print((cardinality == tf.data.experimental.UNKNOWN_CARDINALITY).numpy())\n True\n\n Args:\n dataset: A `tf.data.Dataset` for which to determine cardinality.\n\n Returns:\n A scalar `tf.int64` `Tensor` representing the cardinality of `dataset`. If\n the cardinality is infinite or unknown, the operation returns the named\n constant `INFINITE_CARDINALITY` and `UNKNOWN_CARDINALITY` respectively.\n ", "desc": "Returns the cardinality of `dataset`, if known.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.CheckpointInputPipelineHook", "docs": "Checkpoints input pipeline state every N steps or seconds.\n\n This hook saves the state of the iterators in the `Graph` so that when\n training is resumed the input pipeline continues from where it left off.\n This could potentially avoid overfitting in certain pipelines where the\n number of training steps per eval are small compared to the dataset\n size or if the training pipeline is pre-empted.\n\n Differences from `CheckpointSaverHook`:\n 1. Saves only the input pipelines in the \"iterators\" collection and not the\n global variables or other saveable objects.\n 2. Does not write the `GraphDef` and `MetaGraphDef` to the summary.\n\n Example of checkpointing the training pipeline:\n\n ```python\n est = tf.estimator.Estimator(model_fn)\n while True:\n est.train(\n train_input_fn,\n hooks=[tf.data.experimental.CheckpointInputPipelineHook(est)],\n steps=train_steps_per_eval)\n # Note: We do not pass the hook here.\n metrics = est.evaluate(eval_input_fn)\n if should_stop_the_training(metrics):\n break\n ```\n\n This hook should be used if the input pipeline state needs to be saved\n separate from the model checkpoint. Doing so may be useful for a few reasons:\n 1. The input pipeline checkpoint may be large, if there are large shuffle\n or prefetch buffers for instance, and may bloat the checkpoint size.\n 2. If the input pipeline is shared between training and validation, restoring\n the checkpoint during validation may override the validation input\n pipeline.\n\n For saving the input pipeline checkpoint alongside the model weights use\n `tf.data.experimental.make_saveable_from_iterator` directly to create a\n `SaveableObject` and add to the `SAVEABLE_OBJECTS` collection. Note, however,\n that you will need to be careful not to restore the training iterator during\n eval. You can do that by not adding the iterator to the SAVEABLE_OBJECTS\n collector when building the eval graph.\n ", "desc": "Checkpoints input pipeline state every N steps or seconds.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.choose_from_datasets", "docs": "Creates a dataset that deterministically chooses elements from `datasets`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.choose_from_datasets(...)` instead. Note that, unlike the experimental endpoint, the non-experimental endpoint sets `stop_on_empty_dataset=True` by default. You should set this argument explicitly in case you would like to match the behavior of the experimental endpoint.\n\nFor example, given the following datasets:\n\n```python\ndatasets = [tf.data.Dataset.from_tensors(\"foo\").repeat(),\n tf.data.Dataset.from_tensors(\"bar\").repeat(),\n tf.data.Dataset.from_tensors(\"baz\").repeat()]\n\n# Define a dataset containing `[0, 1, 2, 0, 1, 2, 0, 1, 2]`.\nchoice_dataset = tf.data.Dataset.range(3).repeat(3)\n\nresult = tf.data.experimental.choose_from_datasets(datasets, choice_dataset)\n```\n\nThe elements of `result` will be:\n\n```\n\"foo\", \"bar\", \"baz\", \"foo\", \"bar\", \"baz\", \"foo\", \"bar\", \"baz\"\n```\n\nArgs:\n datasets: A non-empty list of `tf.data.Dataset` objects with compatible\n structure.\n choice_dataset: A `tf.data.Dataset` of scalar `tf.int64` tensors between `0`\n and `len(datasets) - 1`.\n stop_on_empty_dataset: If `True`, selection stops if it encounters an empty\n dataset. If `False`, it skips empty datasets. It is recommended to set it\n to `True`. Otherwise, the selected elements start off as the user intends,\n but may change as input datasets become empty. This can be difficult to\n detect since the dataset starts off looking correct. Default to `False`\n for backward compatibility.\n\nReturns:\n A dataset that interleaves elements from `datasets` according to the values\n of `choice_dataset`.\n\nRaises:\n TypeError: If `datasets` or `choice_dataset` has the wrong type.\n ValueError: If `datasets` is empty.", "desc": "Creates a dataset that deterministically chooses elements from `datasets`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.copy_to_device", "docs": "A transformation that copies dataset elements to the given `target_device`.\n\n Args:\n target_device: The name of a device to which elements will be copied.\n source_device: The original device on which `input_dataset` will be placed.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n ", "desc": "A transformation that copies dataset elements to the given `target_device`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.Counter", "docs": "Creates a `Dataset` that counts from `start` in steps of size `step`.\n\n Unlike `tf.data.Dataset.range` which will stop at some ending number,\n `Counter` will produce elements indefinitely.\n\n >>> dataset = tf.data.experimental.Counter().take(5)\n >>> list(dataset.as_numpy_iterator())\n [0, 1, 2, 3, 4]\n >>> dataset.element_spec\n TensorSpec(shape=(), dtype=tf.int64, name=None)\n >>> dataset = tf.data.experimental.Counter(dtype=tf.int32)\n >>> dataset.element_spec\n TensorSpec(shape=(), dtype=tf.int32, name=None)\n >>> dataset = tf.data.experimental.Counter(start=2).take(5)\n >>> list(dataset.as_numpy_iterator())\n [2, 3, 4, 5, 6]\n >>> dataset = tf.data.experimental.Counter(start=2, step=5).take(5)\n >>> list(dataset.as_numpy_iterator())\n [2, 7, 12, 17, 22]\n >>> dataset = tf.data.experimental.Counter(start=10, step=-1).take(5)\n >>> list(dataset.as_numpy_iterator())\n [10, 9, 8, 7, 6]\n\n Args:\n start: (Optional.) The starting value for the counter. Defaults to 0.\n step: (Optional.) The step size for the counter. Defaults to 1.\n dtype: (Optional.) The data type for counter elements. Defaults to\n `tf.int64`.\n\n Returns:\n A `Dataset` of scalar `dtype` elements.\n ", "desc": "Creates a `Dataset` that counts from `start` in steps of size `step`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.CsvDataset", "docs": "A Dataset comprising lines from one or more CSV files.", "desc": "A Dataset comprising lines from one or more CSV files.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.DatasetStructure", "docs": "Type specification for `tf.data.Dataset`.\n\n See `tf.TypeSpec` for more information about TensorFlow type specifications.\n\n >>> dataset = tf.data.Dataset.range(3)\n >>> tf.data.DatasetSpec.from_value(dataset)\n DatasetSpec(TensorSpec(shape=(), dtype=tf.int64, name=None), TensorShape([]))\n ", "desc": "Type specification for `tf.data.Dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.dense_to_ragged_batch", "docs": "A transformation that batches ragged elements into `tf.RaggedTensor`s.\n\n This transformation combines multiple consecutive elements of the input\n dataset into a single element.\n\n Like `tf.data.Dataset.batch`, the components of the resulting element will\n have an additional outer dimension, which will be `batch_size` (or\n `N % batch_size` for the last element if `batch_size` does not divide the\n number of input elements `N` evenly and `drop_remainder` is `False`). If\n your program depends on the batches having the same outer dimension, you\n should set the `drop_remainder` argument to `True` to prevent the smaller\n batch from being produced.\n\n Unlike `tf.data.Dataset.batch`, the input elements to be batched may have\n different shapes:\n\n * If an input element is a `tf.Tensor` whose static `tf.TensorShape` is\n fully defined, then it is batched as normal.\n * If an input element is a `tf.Tensor` whose static `tf.TensorShape` contains\n one or more axes with unknown size (i.e., `shape[i]=None`), then the output\n will contain a `tf.RaggedTensor` that is ragged up to any of such\n dimensions.\n * If an input element is a `tf.RaggedTensor` or any other type, then it is\n batched as normal.\n\n Example:\n\n >>> dataset = tf.data.Dataset.from_tensor_slices(np.arange(6))\n >>> dataset = dataset.map(lambda x: tf.range(x))\n >>> dataset.element_spec.shape\n TensorShape([None])\n >>> dataset = dataset.apply(\n ... tf.data.experimental.dense_to_ragged_batch(batch_size=2))\n >>> for batch in dataset:\n ... print(batch)\n \n \n \n\n Args:\n batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of\n consecutive elements of this dataset to combine in a single batch.\n drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing\n whether the last batch should be dropped in the case it has fewer than\n `batch_size` elements; the default behavior is not to drop the smaller\n batch.\n row_splits_dtype: The dtype that should be used for the `row_splits` of any\n new ragged tensors. Existing `tf.RaggedTensor` elements do not have their\n row_splits dtype changed.\n\n Returns:\n Dataset: A `Dataset`.\n ", "desc": "A transformation that batches ragged elements into `tf.RaggedTensor`s.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.dense_to_sparse_batch", "docs": "A transformation that batches ragged elements into `tf.sparse.SparseTensor`s.\n\n Like `Dataset.padded_batch()`, this transformation combines multiple\n consecutive elements of the dataset, which might have different\n shapes, into a single element. The resulting element has three\n components (`indices`, `values`, and `dense_shape`), which\n comprise a `tf.sparse.SparseTensor` that represents the same data. The\n `row_shape` represents the dense shape of each row in the\n resulting `tf.sparse.SparseTensor`, to which the effective batch size is\n prepended. For example:\n\n ```python\n # NOTE: The following examples use `{ ... }` to represent the\n # contents of a dataset.\n a = { ['a', 'b', 'c'], ['a', 'b'], ['a', 'b', 'c', 'd'] }\n\n a.apply(tf.data.experimental.dense_to_sparse_batch(\n batch_size=2, row_shape=[6])) ==\n {\n ([[0, 0], [0, 1], [0, 2], [1, 0], [1, 1]], # indices\n ['a', 'b', 'c', 'a', 'b'], # values\n [2, 6]), # dense_shape\n ([[0, 0], [0, 1], [0, 2], [0, 3]],\n ['a', 'b', 'c', 'd'],\n [1, 6])\n }\n ```\n\n Args:\n batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of\n consecutive elements of this dataset to combine in a single batch.\n row_shape: A `tf.TensorShape` or `tf.int64` vector tensor-like object\n representing the equivalent dense shape of a row in the resulting\n `tf.sparse.SparseTensor`. Each element of this dataset must have the same\n rank as `row_shape`, and must have size less than or equal to `row_shape`\n in each dimension.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n ", "desc": "A transformation that batches ragged elements into `tf.sparse.SparseTensor`s.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.DistributeOptions", "docs": "Represents options for distributed data processing.\n\n You can set the distribution options of a dataset through the\n `experimental_distribute` property of `tf.data.Options`; the property is\n an instance of `tf.data.experimental.DistributeOptions`.\n\n ```python\n options = tf.data.Options()\n options.experimental_distribute.auto_shard_policy = AutoShardPolicy.OFF\n dataset = dataset.with_options(options)\n ```\n ", "desc": "Represents options for distributed data processing.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.enable_debug_mode", "docs": "Enables debug mode for tf.data.\n\n Example usage with pdb module:\n ```\n import tensorflow as tf\n import pdb\n\n tf.data.experimental.enable_debug_mode()\n\n def func(x):\n # Python 3.7 and older requires `pdb.Pdb(nosigint=True).set_trace()`\n pdb.set_trace()\n x = x + 1\n return x\n\n dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])\n dataset = dataset.map(func)\n\n for item in dataset:\n print(item)\n ```\n\n The effect of debug mode is two-fold:\n\n 1) Any transformations that would introduce asynchrony, parallelism, or\n non-determinism to the input pipeline execution will be forced to execute\n synchronously, sequentially, and deterministically.\n\n 2) Any user-defined functions passed into tf.data transformations such as\n `map` will be wrapped in `tf.py_function` so that their body is executed\n \"eagerly\" as a Python function as opposed to a traced TensorFlow graph, which\n is the default behavior. Note that even when debug mode is enabled, the\n user-defined function is still traced to infer the shape and type of its\n outputs; as a consequence, any `print` statements or breakpoints will be\n triggered once during the tracing before the actual execution of the input\n pipeline.\n\n NOTE: As the debug mode setting affects the construction of the tf.data input\n pipeline, it should be enabled before any tf.data definitions.\n\n Raises:\n ValueError: When invoked from graph mode.\n ", "desc": "Enables debug mode for tf.data.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.enumerate_dataset", "docs": "A transformation that enumerates the elements of a dataset. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.enumerate()`.\n\nIt is similar to python's `enumerate`.\nFor example:\n\n```python\n# NOTE: The following examples use `{ ... }` to represent the\n# contents of a dataset.\na = { 1, 2, 3 }\nb = { (7, 8), (9, 10) }\n\n# The nested structure of the `datasets` argument determines the\n# structure of elements in the resulting dataset.\na.apply(tf.data.experimental.enumerate_dataset(start=5))\n=> { (5, 1), (6, 2), (7, 3) }\nb.apply(tf.data.experimental.enumerate_dataset())\n=> { (0, (7, 8)), (1, (9, 10)) }\n```\n\nArgs:\n start: A `tf.int64` scalar `tf.Tensor`, representing the start value for\n enumeration.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "A transformation that enumerates the elements of a dataset. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.ExternalStatePolicy", "docs": "Represents how to handle external state during serialization.\n\n See the `tf.data.Options.experimental_external_state_policy` documentation\n for more information.\n ", "desc": "Represents how to handle external state during serialization.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.from_variant", "docs": "Constructs a dataset from the given variant and (nested) structure.\n\n Args:\n variant: A scalar `tf.variant` tensor representing a dataset.\n structure: A (nested) structure of `tf.TypeSpec` objects representing the\n structure of each element in the dataset.\n\n Returns:\n A `tf.data.Dataset` instance.\n ", "desc": "Constructs a dataset from the given variant and (nested) structure.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.get_next_as_optional", "docs": "Returns a `tf.experimental.Optional` with the next element of the iterator. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Iterator.get_next_as_optional()` instead.\n\nIf the iterator has reached the end of the sequence, the returned\n`tf.experimental.Optional` will have no value.\n\nArgs:\n iterator: A `tf.data.Iterator`.\n\nReturns:\n A `tf.experimental.Optional` object which either contains the next element\n of the iterator (if it exists) or no value.", "desc": "Returns a `tf.experimental.Optional` with the next element of the iterator. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.get_single_element", "docs": "Returns the single element of the `dataset` as a nested structure of tensors. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.get_single_element()`.\n\nThe function enables you to use a `tf.data.Dataset` in a stateless\n\"tensor-in tensor-out\" expression, without creating an iterator.\nThis facilitates the ease of data transformation on tensors using the\noptimized `tf.data.Dataset` abstraction on top of them.\n\nFor example, lets consider a `preprocessing_fn` which would take as an\ninput the raw features and returns the processed feature along with\nit's label.\n\n```python\ndef preprocessing_fn(raw_feature):\n # ... the raw_feature is preprocessed as per the use-case\n return feature\n\nraw_features = ... # input batch of BATCH_SIZE elements.\ndataset = (tf.data.Dataset.from_tensor_slices(raw_features)\n .map(preprocessing_fn, num_parallel_calls=BATCH_SIZE)\n .batch(BATCH_SIZE))\n\nprocessed_features = tf.data.experimental.get_single_element(dataset)\n```\n\nIn the above example, the `raw_features` tensor of length=BATCH_SIZE\nwas converted to a `tf.data.Dataset`. Next, each of the `raw_feature` was\nmapped using the `preprocessing_fn` and the processed features were\ngrouped into a single batch. The final `dataset` contains only one element\nwhich is a batch of all the processed features.\n\nNOTE: The `dataset` should contain only one element.\n\nNow, instead of creating an iterator for the `dataset` and retrieving the\nbatch of features, the `tf.data.experimental.get_single_element()` function\nis used to skip the iterator creation process and directly output the batch\nof features.\n\nThis can be particularly useful when your tensor transformations are\nexpressed as `tf.data.Dataset` operations, and you want to use those\ntransformations while serving your model.\n\n# Keras\n\n```python\n\nmodel = ... # A pre-built or custom model\n\nclass PreprocessingModel(tf.keras.Model):\n def __init__(self, model):\n super().__init__(self)\n self.model = model\n\n @tf.function(input_signature=[...])\n def serving_fn(self, data):\n ds = tf.data.Dataset.from_tensor_slices(data)\n ds = ds.map(preprocessing_fn, num_parallel_calls=BATCH_SIZE)\n ds = ds.batch(batch_size=BATCH_SIZE)\n return tf.argmax(\n self.model(tf.data.experimental.get_single_element(ds)),\n axis=-1\n )\n\npreprocessing_model = PreprocessingModel(model)\nyour_exported_model_dir = ... # save the model to this path.\ntf.saved_model.save(preprocessing_model, your_exported_model_dir,\n signatures={'serving_default': preprocessing_model.serving_fn})\n```\n\n# Estimator\n\nIn the case of estimators, you need to generally define a `serving_input_fn`\nwhich would require the features to be processed by the model while\ninferencing.\n\n```python\ndef serving_input_fn():\n\n raw_feature_spec = ... # Spec for the raw_features\n input_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn(\n raw_feature_spec, default_batch_size=None)\n )\n serving_input_receiver = input_fn()\n raw_features = serving_input_receiver.features\n\n def preprocessing_fn(raw_feature):\n # ... the raw_feature is preprocessed as per the use-case\n return feature\n\n dataset = (tf.data.Dataset.from_tensor_slices(raw_features)\n .map(preprocessing_fn, num_parallel_calls=BATCH_SIZE)\n .batch(BATCH_SIZE))\n\n processed_features = tf.data.experimental.get_single_element(dataset)\n\n # Please note that the value of `BATCH_SIZE` should be equal to\n # the size of the leading dimension of `raw_features`. This ensures\n # that `dataset` has only element, which is a pre-requisite for\n # using `tf.data.experimental.get_single_element(dataset)`.\n\n return tf.estimator.export.ServingInputReceiver(\n processed_features, serving_input_receiver.receiver_tensors)\n\nestimator = ... # A pre-built or custom estimator\nestimator.export_saved_model(your_exported_model_dir, serving_input_fn)\n```\n\nArgs:\n dataset: A `tf.data.Dataset` object containing a single element.\n\nReturns:\n A nested structure of `tf.Tensor` objects, corresponding to the single\n element of `dataset`.\n\nRaises:\n TypeError: if `dataset` is not a `tf.data.Dataset` object.\n InvalidArgumentError: (at runtime) if `dataset` does not contain exactly\n one element.", "desc": "Returns the single element of the `dataset` as a nested structure of tensors. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.get_structure", "docs": "Returns the type signature for elements of the input dataset / iterator.\n\n Args:\n dataset_or_iterator: A `tf.data.Dataset` or an `tf.data.Iterator`.\n\n Returns:\n A (nested) structure of `tf.TypeSpec` objects matching the structure of an\n element of `dataset_or_iterator` and specifying the type of individual\n components.\n\n Raises:\n TypeError: If input is not a `tf.data.Dataset` or an `tf.data.Iterator`\n object.\n ", "desc": "Returns the type signature for elements of the input dataset / iterator.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.group_by_reducer", "docs": "A transformation that groups elements and performs a reduction.\n\n This transformation maps element of a dataset to a key using `key_func` and\n groups the elements by key. The `reducer` is used to process each group; its\n `init_func` is used to initialize state for each group when it is created, the\n `reduce_func` is used to update the state every time an element is mapped to\n the matching group, and the `finalize_func` is used to map the final state to\n an output value.\n\n Args:\n key_func: A function mapping a nested structure of tensors\n (having shapes and types defined by `self.output_shapes` and\n `self.output_types`) to a scalar `tf.int64` tensor.\n reducer: An instance of `Reducer`, which captures the reduction logic using\n the `init_func`, `reduce_func`, and `finalize_func` functions.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n ", "desc": "A transformation that groups elements and performs a reduction.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.group_by_window", "docs": "A transformation that groups windows of elements by key and reduces them. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.group_by_window(...)`.\n\nThis transformation maps each consecutive element in a dataset to a key\nusing `key_func` and groups the elements by key. It then applies\n`reduce_func` to at most `window_size_func(key)` elements matching the same\nkey. All except the final window for each key will contain\n`window_size_func(key)` elements; the final window may be smaller.\n\nYou may provide either a constant `window_size` or a window size determined by\nthe key through `window_size_func`.\n\nArgs:\n key_func: A function mapping a nested structure of tensors\n (having shapes and types defined by `self.output_shapes` and\n `self.output_types`) to a scalar `tf.int64` tensor.\n reduce_func: A function mapping a key and a dataset of up to `window_size`\n consecutive elements matching that key to another dataset.\n window_size: A `tf.int64` scalar `tf.Tensor`, representing the number of\n consecutive elements matching the same key to combine in a single\n batch, which will be passed to `reduce_func`. Mutually exclusive with\n `window_size_func`.\n window_size_func: A function mapping a key to a `tf.int64` scalar\n `tf.Tensor`, representing the number of consecutive elements matching\n the same key to combine in a single batch, which will be passed to\n `reduce_func`. Mutually exclusive with `window_size`.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\nRaises:\n ValueError: if neither or both of {`window_size`, `window_size_func`} are\n passed.", "desc": "A transformation that groups windows of elements by key and reduces them. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.ignore_errors", "docs": "Creates a `Dataset` from another `Dataset` and silently ignores any errors.\n\n Use this transformation to produce a dataset that contains the same elements\n as the input, but silently drops any elements that caused an error. For\n example:\n\n ```python\n dataset = tf.data.Dataset.from_tensor_slices([1., 2., 0., 4.])\n\n # Computing `tf.debugging.check_numerics(1. / 0.)` will raise an\n InvalidArgumentError.\n dataset = dataset.map(lambda x: tf.debugging.check_numerics(1. / x, \"error\"))\n\n # Using `ignore_errors()` will drop the element that causes an error.\n dataset =\n dataset.apply(tf.data.experimental.ignore_errors()) # ==> {1., 0.5, 0.2}\n ```\n Args:\n log_warning: (Optional.) A 'tf.bool' scalar indicating whether ignored\n errors should be logged to stderr. Defaults to 'False'.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n ", "desc": "Creates a `Dataset` from another `Dataset` and silently ignores any errors.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.make_batched_features_dataset", "docs": "Returns a `Dataset` of feature dictionaries from `Example` protos.\n\n If label_key argument is provided, returns a `Dataset` of tuple\n comprising of feature dictionaries and label.\n\n Example:\n\n ```\n serialized_examples = [\n features {\n feature { key: \"age\" value { int64_list { value: [ 0 ] } } }\n feature { key: \"gender\" value { bytes_list { value: [ \"f\" ] } } }\n feature { key: \"kws\" value { bytes_list { value: [ \"code\", \"art\" ] } } }\n },\n features {\n feature { key: \"age\" value { int64_list { value: [] } } }\n feature { key: \"gender\" value { bytes_list { value: [ \"f\" ] } } }\n feature { key: \"kws\" value { bytes_list { value: [ \"sports\" ] } } }\n }\n ]\n ```\n\n We can use arguments:\n\n ```\n features: {\n \"age\": FixedLenFeature([], dtype=tf.int64, default_value=-1),\n \"gender\": FixedLenFeature([], dtype=tf.string),\n \"kws\": VarLenFeature(dtype=tf.string),\n }\n ```\n\n And the expected output is:\n\n ```python\n {\n \"age\": [[0], [-1]],\n \"gender\": [[\"f\"], [\"f\"]],\n \"kws\": SparseTensor(\n indices=[[0, 0], [0, 1], [1, 0]],\n values=[\"code\", \"art\", \"sports\"]\n dense_shape=[2, 2]),\n }\n ```\n\n Args:\n file_pattern: List of files or patterns of file paths containing\n `Example` records. See `tf.io.gfile.glob` for pattern rules.\n batch_size: An int representing the number of records to combine\n in a single batch.\n features: A `dict` mapping feature keys to `FixedLenFeature` or\n `VarLenFeature` values. See `tf.io.parse_example`.\n reader: A function or class that can be\n called with a `filenames` tensor and (optional) `reader_args` and returns\n a `Dataset` of `Example` tensors. Defaults to `tf.data.TFRecordDataset`.\n label_key: (Optional) A string corresponding to the key labels are stored in\n `tf.Examples`. If provided, it must be one of the `features` key,\n otherwise results in `ValueError`.\n reader_args: Additional arguments to pass to the reader class.\n num_epochs: Integer specifying the number of times to read through the\n dataset. If None, cycles through the dataset forever. Defaults to `None`.\n shuffle: A boolean, indicates whether the input should be shuffled. Defaults\n to `True`.\n shuffle_buffer_size: Buffer size of the ShuffleDataset. A large capacity\n ensures better shuffling but would increase memory usage and startup time.\n shuffle_seed: Randomization seed to use for shuffling.\n prefetch_buffer_size: Number of feature batches to prefetch in order to\n improve performance. Recommended value is the number of batches consumed\n per training step. Defaults to auto-tune.\n reader_num_threads: Number of threads used to read `Example` records. If >1,\n the results will be interleaved. Defaults to `1`.\n parser_num_threads: Number of threads to use for parsing `Example` tensors\n into a dictionary of `Feature` tensors. Defaults to `2`.\n sloppy_ordering: If `True`, reading performance will be improved at\n the cost of non-deterministic ordering. If `False`, the order of elements\n produced is deterministic prior to shuffling (elements are still\n randomized if `shuffle=True`. Note that if the seed is set, then order\n of elements after shuffling is deterministic). Defaults to `False`.\n drop_final_batch: If `True`, and the batch size does not evenly divide the\n input dataset size, the final smaller batch will be dropped. Defaults to\n `False`.\n\n Returns:\n A dataset of `dict` elements, (or a tuple of `dict` elements and label).\n Each `dict` maps feature keys to `Tensor` or `SparseTensor` objects.\n\n Raises:\n TypeError: If `reader` is of the wrong type.\n ValueError: If `label_key` is not one of the `features` keys.\n ", "desc": "Returns a `Dataset` of feature dictionaries from `Example` protos.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.make_csv_dataset", "docs": "Reads CSV files into a dataset.\n\n Reads CSV files into a dataset, where each element of the dataset is a\n (features, labels) tuple that corresponds to a batch of CSV rows. The features\n dictionary maps feature column names to `Tensor`s containing the corresponding\n feature data, and labels is a `Tensor` containing the batch's label data.\n\n By default, the first rows of the CSV files are expected to be headers listing\n the column names. If the first rows are not headers, set `header=False` and\n provide the column names with the `column_names` argument.\n\n By default, the dataset is repeated indefinitely, reshuffling the order each\n time. This behavior can be modified by setting the `num_epochs` and `shuffle`\n arguments.\n\n For example, suppose you have a CSV file containing\n\n | Feature_A | Feature_B |\n | --------- | --------- |\n | 1 | \"a\" |\n | 2 | \"b\" |\n | 3 | \"c\" |\n | 4 | \"d\" |\n\n ```\n # No label column specified\n dataset = tf.data.experimental.make_csv_dataset(filename, batch_size=2)\n iterator = dataset.as_numpy_iterator()\n print(dict(next(iterator)))\n # prints a dictionary of batched features:\n # OrderedDict([('Feature_A', array([1, 4], dtype=int32)),\n # ('Feature_B', array([b'a', b'd'], dtype=object))])\n ```\n\n ```\n # Set Feature_B as label column\n dataset = tf.data.experimental.make_csv_dataset(\n filename, batch_size=2, label_name=\"Feature_B\")\n iterator = dataset.as_numpy_iterator()\n print(next(iterator))\n # prints (features, labels) tuple:\n # (OrderedDict([('Feature_A', array([1, 2], dtype=int32))]),\n # array([b'a', b'b'], dtype=object))\n ```\n\n See the\n [Load CSV data guide](https://www.tensorflow.org/tutorials/load_data/csv) for\n more examples of using `make_csv_dataset` to read CSV data.\n\n Args:\n file_pattern: List of files or patterns of file paths containing CSV\n records. See `tf.io.gfile.glob` for pattern rules.\n batch_size: An int representing the number of records to combine\n in a single batch.\n column_names: An optional list of strings that corresponds to the CSV\n columns, in order. One per column of the input record. If this is not\n provided, infers the column names from the first row of the records.\n These names will be the keys of the features dict of each dataset element.\n column_defaults: A optional list of default values for the CSV fields. One\n item per selected column of the input record. Each item in the list is\n either a valid CSV dtype (float32, float64, int32, int64, or string), or a\n `Tensor` with one of the aforementioned types. The tensor can either be\n a scalar default value (if the column is optional), or an empty tensor (if\n the column is required). If a dtype is provided instead of a tensor, the\n column is also treated as required. If this list is not provided, tries\n to infer types based on reading the first num_rows_for_inference rows of\n files specified, and assumes all columns are optional, defaulting to `0`\n for numeric values and `\"\"` for string values. If both this and\n `select_columns` are specified, these must have the same lengths, and\n `column_defaults` is assumed to be sorted in order of increasing column\n index.\n label_name: A optional string corresponding to the label column. If\n provided, the data for this column is returned as a separate `Tensor` from\n the features dictionary, so that the dataset complies with the format\n expected by a `tf.Estimator.train` or `tf.Estimator.evaluate` input\n function.\n select_columns: An optional list of integer indices or string column\n names, that specifies a subset of columns of CSV data to select. If\n column names are provided, these must correspond to names provided in\n `column_names` or inferred from the file header lines. When this argument\n is specified, only a subset of CSV columns will be parsed and returned,\n corresponding to the columns specified. Using this results in faster\n parsing and lower memory usage. If both this and `column_defaults` are\n specified, these must have the same lengths, and `column_defaults` is\n assumed to be sorted in order of increasing column index.\n field_delim: An optional `string`. Defaults to `\",\"`. Char delimiter to\n separate fields in a record.\n use_quote_delim: An optional bool. Defaults to `True`. If false, treats\n double quotation marks as regular characters inside of the string fields.\n na_value: Additional string to recognize as NA/NaN.\n header: A bool that indicates whether the first rows of provided CSV files\n correspond to header lines with column names, and should not be included\n in the data.\n num_epochs: An int specifying the number of times this dataset is repeated.\n If None, cycles through the dataset forever.\n shuffle: A bool that indicates whether the input should be shuffled.\n shuffle_buffer_size: Buffer size to use for shuffling. A large buffer size\n ensures better shuffling, but increases memory usage and startup time.\n shuffle_seed: Randomization seed to use for shuffling.\n prefetch_buffer_size: An int specifying the number of feature\n batches to prefetch for performance improvement. Recommended value is the\n number of batches consumed per training step. Defaults to auto-tune.\n num_parallel_reads: Number of threads used to read CSV records from files.\n If >1, the results will be interleaved. Defaults to `1`.\n sloppy: If `True`, reading performance will be improved at\n the cost of non-deterministic ordering. If `False`, the order of elements\n produced is deterministic prior to shuffling (elements are still\n randomized if `shuffle=True`. Note that if the seed is set, then order\n of elements after shuffling is deterministic). Defaults to `False`.\n num_rows_for_inference: Number of rows of a file to use for type inference\n if record_defaults is not provided. If None, reads all the rows of all\n the files. Defaults to 100.\n compression_type: (Optional.) A `tf.string` scalar evaluating to one of\n `\"\"` (no compression), `\"ZLIB\"`, or `\"GZIP\"`. Defaults to no compression.\n ignore_errors: (Optional.) If `True`, ignores errors with CSV file parsing,\n such as malformed data or empty lines, and moves on to the next valid\n CSV record. Otherwise, the dataset raises an error and stops processing\n when encountering any invalid records. Defaults to `False`.\n\n Returns:\n A dataset, where each element is a (features, labels) tuple that corresponds\n to a batch of `batch_size` CSV rows. The features dictionary maps feature\n column names to `Tensor`s containing the corresponding column data, and\n labels is a `Tensor` containing the column data for the label column\n specified by `label_name`.\n\n Raises:\n ValueError: If any of the arguments is malformed.\n ", "desc": "Reads CSV files into a dataset.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.make_saveable_from_iterator", "docs": "Returns a SaveableObject for saving/restoring iterator state using Saver. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\n`make_saveable_from_iterator` is intended for use in TF1 with `tf.compat.v1.Saver`. In TF2, use `tf.train.Checkpoint` instead.\n\nArgs:\n iterator: Iterator.\n external_state_policy: A string that identifies how to handle input\n pipelines that depend on external state. Possible values are\n 'ignore': The external state is silently ignored.\n 'warn': The external state is ignored, logging a warning.\n 'fail': The operation fails upon encountering external state.\n By default we set it to 'fail'.\n\nReturns:\n A SaveableObject for saving/restoring iterator state using Saver.\n\nRaises:\n ValueError: If iterator does not support checkpointing.\n ValueError: If `external_state_policy` is not one of 'warn', 'ignore' or\n 'fail'.\n\nFor example:\n\n```python\nwith tf.Graph().as_default():\n ds = tf.data.Dataset.range(10)\n iterator = ds.make_initializable_iterator()\n # Build the iterator SaveableObject.\n saveable_obj = tf.data.experimental.make_saveable_from_iterator(iterator)\n # Add the SaveableObject to the SAVEABLE_OBJECTS collection so\n # it can be automatically saved using Saver.\n tf.compat.v1.add_to_collection(tf.GraphKeys.SAVEABLE_OBJECTS, saveable_obj)\n saver = tf.compat.v1.train.Saver()\n\n while continue_training:\n ... Perform training ...\n if should_save_checkpoint:\n saver.save()\n```\n\nNote: When restoring the iterator, the existing iterator state is completely\ndiscarded. This means that any changes you may have made to the Dataset\ngraph will be discarded as well! This includes the new Dataset graph\nthat you may have built during validation. So, while running validation,\nmake sure to run the initializer for the validation input pipeline after\nrestoring the checkpoint.\n\nNote: Not all iterators support checkpointing yet. Attempting to save the\nstate of an unsupported iterator will throw an error.", "desc": "Returns a SaveableObject for saving/restoring iterator state using Saver. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.map_and_batch", "docs": "Fused implementation of `map` and `batch`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.map(map_func, num_parallel_calls)` followed by `tf.data.Dataset.batch(batch_size, drop_remainder)`. Static tf.data optimizations will take care of using the fused implementation.\n\nMaps `map_func` across `batch_size` consecutive elements of this dataset\nand then combines them into a batch. Functionally, it is equivalent to `map`\nfollowed by `batch`. This API is temporary and deprecated since input pipeline\noptimization now fuses consecutive `map` and `batch` operations automatically.\n\nArgs:\n map_func: A function mapping a nested structure of tensors to another\n nested structure of tensors.\n batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of\n consecutive elements of this dataset to combine in a single batch.\n num_parallel_batches: (Optional.) A `tf.int64` scalar `tf.Tensor`,\n representing the number of batches to create in parallel. On one hand,\n higher values can help mitigate the effect of stragglers. On the other\n hand, higher values can increase contention if CPU is scarce.\n drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing\n whether the last batch should be dropped in case its size is smaller than\n desired; the default behavior is not to drop the smaller batch.\n num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,\n representing the number of elements to process in parallel. If not\n specified, `batch_size * num_parallel_batches` elements will be processed\n in parallel. If the value `tf.data.AUTOTUNE` is used, then\n the number of parallel calls is set dynamically based on available CPU.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\nRaises:\n ValueError: If both `num_parallel_batches` and `num_parallel_calls` are\n specified.", "desc": "Fused implementation of `map` and `batch`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.map_and_batch_with_legacy_function", "docs": "Fused implementation of `map` and `batch`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.experimental.map_and_batch()\n\nNOTE: This is an escape hatch for existing uses of `map_and_batch` that do not\nwork with V2 functions. New uses are strongly discouraged and existing uses\nshould migrate to `map_and_batch` as this method will not be removed in V2.\n\nArgs:\n map_func: A function mapping a nested structure of tensors to another\n nested structure of tensors.\n batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of\n consecutive elements of this dataset to combine in a single batch.\n num_parallel_batches: (Optional.) A `tf.int64` scalar `tf.Tensor`,\n representing the number of batches to create in parallel. On one hand,\n higher values can help mitigate the effect of stragglers. On the other\n hand, higher values can increase contention if CPU is scarce.\n drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing\n whether the last batch should be dropped in case its size is smaller than\n desired; the default behavior is not to drop the smaller batch.\n num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,\n representing the number of elements to process in parallel. If not\n specified, `batch_size * num_parallel_batches` elements will be processed\n in parallel. If the value `tf.data.AUTOTUNE` is used, then\n the number of parallel calls is set dynamically based on available CPU.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\nRaises:\n ValueError: If both `num_parallel_batches` and `num_parallel_calls` are\n specified.", "desc": "Fused implementation of `map` and `batch`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.OptimizationOptions", "docs": "Represents options for dataset optimizations.\n\n You can set the optimization options of a dataset through the\n `experimental_optimization` property of `tf.data.Options`; the property is\n an instance of `tf.data.experimental.OptimizationOptions`.\n\n ```python\n options = tf.data.Options()\n options.experimental_optimization.noop_elimination = True\n options.experimental_optimization.apply_default_optimizations = False\n dataset = dataset.with_options(options)\n ```\n ", "desc": "Represents options for dataset optimizations.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.Optional", "docs": "Represents a value that may or may not be present.\n\n A `tf.experimental.Optional` can represent the result of an operation that may\n fail as a value, rather than raising an exception and halting execution. For\n example, `tf.data.Iterator.get_next_as_optional()` returns a\n `tf.experimental.Optional` that either contains the next element of an\n iterator if one exists, or an \"empty\" value that indicates the end of the\n sequence has been reached.\n\n `tf.experimental.Optional` can only be used with values that are convertible\n to `tf.Tensor` or `tf.CompositeTensor`.\n\n One can create a `tf.experimental.Optional` from a value using the\n `from_value()` method:\n\n >>> optional = tf.experimental.Optional.from_value(42)\n >>> print(optional.has_value())\n tf.Tensor(True, shape=(), dtype=bool)\n >>> print(optional.get_value())\n tf.Tensor(42, shape=(), dtype=int32)\n\n or without a value using the `empty()` method:\n\n >>> optional = tf.experimental.Optional.empty(\n ... tf.TensorSpec(shape=(), dtype=tf.int32, name=None))\n >>> print(optional.has_value())\n tf.Tensor(False, shape=(), dtype=bool)\n ", "desc": "Represents a value that may or may not be present.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.OptionalStructure", "docs": "Type specification for `tf.experimental.Optional`.\n\n For instance, `tf.OptionalSpec` can be used to define a tf.function that takes\n `tf.experimental.Optional` as an input argument:\n\n >>> @tf.function(input_signature=[tf.OptionalSpec(\n ... tf.TensorSpec(shape=(), dtype=tf.int32, name=None))])\n ... def maybe_square(optional):\n ... if optional.has_value():\n ... x = optional.get_value()\n ... return x * x\n ... return -1\n >>> optional = tf.experimental.Optional.from_value(5)\n >>> print(maybe_square(optional))\n tf.Tensor(25, shape=(), dtype=int32)\n\n Attributes:\n element_spec: A (nested) structure of `TypeSpec` objects that represents the\n type specification of the optional element.\n ", "desc": "Type specification for `tf.experimental.Optional`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.parallel_interleave", "docs": "A parallel version of the `Dataset.interleave()` transformation. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.interleave(map_func, cycle_length, block_length, num_parallel_calls=tf.data.AUTOTUNE)` instead. If sloppy execution is desired, use `tf.data.Options.deterministic`.\n\n`parallel_interleave()` maps `map_func` across its input to produce nested\ndatasets, and outputs their elements interleaved. Unlike\n`tf.data.Dataset.interleave`, it gets elements from `cycle_length` nested\ndatasets in parallel, which increases the throughput, especially in the\npresence of stragglers. Furthermore, the `sloppy` argument can be used to\nimprove performance, by relaxing the requirement that the outputs are produced\nin a deterministic order, and allowing the implementation to skip over nested\ndatasets whose elements are not readily available when requested.\n\nExample usage:\n\n```python\n# Preprocess 4 files concurrently.\nfilenames = tf.data.Dataset.list_files(\"/path/to/data/train*.tfrecords\")\ndataset = filenames.apply(\n tf.data.experimental.parallel_interleave(\n lambda filename: tf.data.TFRecordDataset(filename),\n cycle_length=4))\n```\n\nWARNING: If `sloppy` is `True`, the order of produced elements is not\ndeterministic.\n\nArgs:\n map_func: A function mapping a nested structure of tensors to a `Dataset`.\n cycle_length: The number of input `Dataset`s to interleave from in parallel.\n block_length: The number of consecutive elements to pull from an input\n `Dataset` before advancing to the next input `Dataset`.\n sloppy: A boolean controlling whether determinism should be traded for\n performance by allowing elements to be produced out of order. If `sloppy`\n is `None`, the `tf.data.Options.deterministic` dataset option (`True` by\n default) is used to decide whether to enforce a deterministic order.\n buffer_output_elements: The number of elements each iterator being\n interleaved should buffer (similar to the `.prefetch()` transformation for\n each interleaved iterator).\n prefetch_input_elements: The number of input elements to transform to\n iterators before they are needed for interleaving.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "A parallel version of the `Dataset.interleave()` transformation. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.parse_example_dataset", "docs": "A transformation that parses `Example` protos into a `dict` of tensors.\n\n Parses a number of serialized `Example` protos given in `serialized`. We refer\n to `serialized` as a batch with `batch_size` many entries of individual\n `Example` protos.\n\n This op parses serialized examples into a dictionary mapping keys to `Tensor`,\n `SparseTensor`, and `RaggedTensor` objects. `features` is a dict from keys to\n `VarLenFeature`, `RaggedFeature`, `SparseFeature`, and `FixedLenFeature`\n objects. Each `VarLenFeature` and `SparseFeature` is mapped to a\n `SparseTensor`; each `RaggedFeature` is mapped to a `RaggedTensor`; and each\n `FixedLenFeature` is mapped to a `Tensor`. See `tf.io.parse_example` for more\n details about feature dictionaries.\n\n Args:\n features: A `dict` mapping feature keys to `FixedLenFeature`,\n `VarLenFeature`, `RaggedFeature`, and `SparseFeature` values.\n num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,\n representing the number of parsing processes to call in parallel.\n deterministic: (Optional.) A boolean controlling whether determinism\n should be traded for performance by allowing elements to be produced out\n of order if some parsing calls complete faster than others. If\n `deterministic` is `None`, the\n `tf.data.Options.deterministic` dataset option (`True` by default) is used\n to decide whether to produce elements deterministically.\n\n Returns:\n A dataset transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n\n Raises:\n ValueError: if features argument is None.\n ", "desc": "A transformation that parses `Example` protos into a `dict` of tensors.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.prefetch_to_device", "docs": "A transformation that prefetches dataset values to the given `device`.\n\n NOTE: Although the transformation creates a `tf.data.Dataset`, the\n transformation must be the final `Dataset` in the input pipeline.\n\n For example,\n >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])\n >>> dataset = dataset.apply(tf.data.experimental.prefetch_to_device(\"/cpu:0\"))\n >>> for element in dataset:\n ... print(f'Tensor {element} is on device {element.device}')\n Tensor 1 is on device /job:localhost/replica:0/task:0/device:CPU:0\n Tensor 2 is on device /job:localhost/replica:0/task:0/device:CPU:0\n Tensor 3 is on device /job:localhost/replica:0/task:0/device:CPU:0\n\n Args:\n device: A string. The name of a device to which elements will be prefetched.\n buffer_size: (Optional.) The number of elements to buffer on `device`.\n Defaults to an automatically chosen value.\n\n Returns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.\n ", "desc": "A transformation that prefetches dataset values to the given `device`.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.RaggedTensorStructure", "docs": "DEPRECATED FUNCTION\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.RaggedTensorSpec` instead.", "desc": "DEPRECATED FUNCTION", "type": "API"}, {"name": "tf.compat.v1.data.experimental.RandomDataset", "docs": "A `Dataset` of pseudorandom values. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.random(...)`.", "desc": "A `Dataset` of pseudorandom values. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.Reducer", "docs": "A reducer is used for reducing a set of elements.\n\n A reducer is represented as a tuple of the three functions:\n - init_func - to define initial value: key => initial state\n - reducer_func - operation to perform on values with same key: (old state, input) => new state\n - finalize_func - value to return in the end: state => result\n \n For example,\n \n ```\n def init_func(_):\n return (0.0, 0.0)\n\n def reduce_func(state, value):\n return (state[0] + value['features'], state[1] + 1)\n\n def finalize_func(s, n):\n return s / n\n\n reducer = tf.data.experimental.Reducer(init_func, reduce_func, finalize_func)\n ```\n ", "desc": "A reducer is used for reducing a set of elements.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.rejection_resample", "docs": "A transformation that resamples a dataset to achieve a target distribution. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.rejection_resample(...)`.\n\n**NOTE** Resampling is performed via rejection sampling; some fraction\nof the input values will be dropped.\n\nArgs:\n class_func: A function mapping an element of the input dataset to a scalar\n `tf.int32` tensor. Values should be in `[0, num_classes)`.\n target_dist: A floating point type tensor, shaped `[num_classes]`.\n initial_dist: (Optional.) A floating point type tensor, shaped\n `[num_classes]`. If not provided, the true class distribution is\n estimated live in a streaming fashion.\n seed: (Optional.) Python integer seed for the resampler.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "A transformation that resamples a dataset to achieve a target distribution. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.sample_from_datasets", "docs": "Samples elements at random from the datasets in `datasets`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.sample_from_datasets(...)`.\n\nCreates a dataset by interleaving elements of `datasets` with `weight[i]`\nprobability of picking an element from dataset `i`. Sampling is done without\nreplacement. For example, suppose we have 2 datasets:\n\n```python\ndataset1 = tf.data.Dataset.range(0, 3)\ndataset2 = tf.data.Dataset.range(100, 103)\n```\n\nSuppose also that we sample from these 2 datasets with the following weights:\n\n```python\nsample_dataset = tf.data.Dataset.sample_from_datasets(\n [dataset1, dataset2], weights=[0.5, 0.5])\n```\n\nOne possible outcome of elements in sample_dataset is:\n\n```\nprint(list(sample_dataset.as_numpy_iterator()))\n# [100, 0, 1, 101, 2, 102]\n```\n\nArgs:\n datasets: A non-empty list of `tf.data.Dataset` objects with compatible\n structure.\n weights: (Optional.) A list or Tensor of `len(datasets)` floating-point\n values where `weights[i]` represents the probability to sample from\n `datasets[i]`, or a `tf.data.Dataset` object where each element is such a\n list. Defaults to a uniform distribution across `datasets`.\n seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random\n seed that will be used to create the distribution. See\n `tf.random.set_seed` for behavior.\n stop_on_empty_dataset: If `True`, sampling stops if it encounters an empty\n dataset. If `False`, it skips empty datasets. It is recommended to set it\n to `True`. Otherwise, the distribution of samples starts off as the user\n intends, but may change as input datasets become empty. This can be\n difficult to detect since the dataset starts off looking correct. Default\n to `False` for backward compatibility.\n\nReturns:\n A dataset that interleaves elements from `datasets` at random, according to\n `weights` if provided, otherwise with uniform probability.\n\nRaises:\n TypeError: If the `datasets` or `weights` arguments have the wrong type.\n ValueError:\n - If `datasets` is empty, or\n - If `weights` is specified and does not match the length of `datasets`.", "desc": "Samples elements at random from the datasets in `datasets`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.scan", "docs": "A transformation that scans a function across an input dataset. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.scan(...) instead\n\nThis transformation is a stateful relative of `tf.data.Dataset.map`.\nIn addition to mapping `scan_func` across the elements of the input dataset,\n`scan()` accumulates one or more state tensors, whose initial values are\n`initial_state`.\n\nArgs:\n initial_state: A nested structure of tensors, representing the initial state\n of the accumulator.\n scan_func: A function that maps `(old_state, input_element)` to\n `(new_state, output_element)`. It must take two arguments and return a\n pair of nested structures of tensors. The `new_state` must match the\n structure of `initial_state`.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "A transformation that scans a function across an input dataset. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service", "docs": "API for using the tf.data service.\n\nThis module contains:\n\n1. tf.data server implementations for running the tf.data service.\n2. APIs for registering datasets with the tf.data service and reading from\n the registered datasets.\n\nThe tf.data service provides the following benefits:\n\n- Horizontal scaling of tf.data input pipeline processing to solve input\n bottlenecks.\n- Data coordination for distributed training. Coordinated reads\n enable all replicas to train on similar-length examples across each global\n training step, improving step times in synchronous training.\n- Dynamic balancing of data across training replicas.\n\n>>> dispatcher = tf.data.experimental.service.DispatchServer()\n>>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n>>> worker = tf.data.experimental.service.WorkerServer(\n... tf.data.experimental.service.WorkerConfig(\n... dispatcher_address=dispatcher_address))\n>>> dataset = tf.data.Dataset.range(10)\n>>> dataset = dataset.apply(tf.data.experimental.service.distribute(\n... processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n... service=dispatcher.target))\n>>> print(list(dataset.as_numpy_iterator()))\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n## Setup\n\nThis section goes over how to set up the tf.data service.\n\n### Run tf.data servers\n\nThe tf.data service consists of one dispatch server and `n` worker servers.\ntf.data servers should be brought up alongside your training jobs, then brought\ndown when the jobs are finished.\nUse `tf.data.experimental.service.DispatchServer` to start a dispatch server,\nand `tf.data.experimental.service.WorkerServer` to start worker servers. Servers\ncan be run in the same process for testing purposes, or scaled up on separate\nmachines.\n\nSee https://github.com/tensorflow/ecosystem/tree/master/data_service for an\nexample of using Google Kubernetes Engine (GKE) to manage the tf.data service.\nNote that the server implementation in\n[tf_std_data_server.py](https://github.com/tensorflow/ecosystem/blob/master/data_service/tf_std_data_server.py)\nis not GKE-specific, and can be used to run the tf.data service in other\ncontexts.\n\n### Custom ops\n\nIf your dataset uses custom ops, these ops need to be made available to tf.data\nservers by calling\n[load_op_library](https://www.tensorflow.org/api_docs/python/tf/load_op_library)\nfrom the dispatcher and worker processes at startup.\n\n## Usage\n\nUsers interact with tf.data service by programmatically registering their\ndatasets with tf.data service, then creating datasets that read from the\nregistered datasets. The\n[register_dataset](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/register_dataset)\nfunction registers a dataset, then the\n[from_dataset_id](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/from_dataset_id)\nfunction creates a new dataset which reads from the registered dataset.\nThe\n[distribute](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/distribute)\nfunction wraps `register_dataset` and `from_dataset_id` into a single convenient\ntransformation which registers its input dataset and then reads from it.\n`distribute` enables tf.data service to be used with a one-line code change.\nHowever, it assumes that the dataset is created and consumed by the same entity\nand this assumption might not always be valid or desirable. In particular, in\ncertain scenarios, such as distributed training, it might be desirable to\ndecouple the creation and consumption of the dataset (via `register_dataset`\nand `from_dataset_id` respectively) to avoid having to create the dataset on\neach of the training workers.\n\n### Example\n\n#### `distribute`\n\nTo use the `distribute` transformation, apply the transformation after the\nprefix of your input pipeline that you would like to be executed using tf.data\nservice (typically at the end).\n\n```\ndataset = ... # Define your dataset here.\n# Move dataset processing from the local machine to the tf.data service\ndataset = dataset.apply(\n tf.data.experimental.service.distribute(\n processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n service=FLAGS.tf_data_service_address,\n job_name=\"shared_job\"))\n# Any transformations added after `distribute` will be run on the local machine.\ndataset = dataset.prefetch(1)\n```\n\nThe above code will create a tf.data service \"job\", which iterates through the\ndataset to generate data. To share the data from a job across multiple clients\n(e.g. when using TPUStrategy or MultiWorkerMirroredStrategy), set a common\n`job_name` across all clients.\n\n#### `register_dataset` and `from_dataset_id`\n\n`register_dataset` registers a dataset with the tf.data service, returning a\ndataset id for the registered dataset. `from_dataset_id` creates a dataset that\nreads from the registered dataset. These APIs can be used to reduce dataset\nbuilding time for distributed training. Instead of building the dataset on all\ntraining workers, we can build the dataset just once and then register the\ndataset using `register_dataset`. Then all workers can call `from_dataset_id`\nwithout needing to build the dataset themselves.\n\n```\ndataset = ... # Define your dataset here.\ndataset_id = tf.data.experimental.service.register_dataset(\n service=FLAGS.tf_data_service_address,\n dataset=dataset)\n# Use `from_dataset_id` to create per-worker datasets.\nper_worker_datasets = {}\nfor worker in workers:\n per_worker_datasets[worker] = tf.data.experimental.service.from_dataset_id(\n processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n service=FLAGS.tf_data_service_address,\n dataset_id=dataset_id,\n job_name=\"shared_job\")\n```\n\n### Processing Modes\n\n`processing_mode` specifies how to shard a dataset among tf.data service\nworkers. tf.data service supports `OFF`, `DYNAMIC`, `FILE`, `DATA`,\n`FILE_OR_DATA`, `HINT` sharding policies.\n\nOFF: No sharding will be performed. The entire input dataset will be processed\nindependently by each of the tf.data service workers. For this reason, it is\nimportant to shuffle data (e.g. filenames) non-deterministically, so that each\nworker will process the elements of the dataset in a different order. This mode\ncan be used to distribute datasets that aren't splittable.\n\nIf a worker is added or restarted during ShardingPolicy.OFF processing, the\nworker will instantiate a new copy of the dataset and begin producing data from\nthe beginning.\n\n#### Dynamic Sharding\n\nDYNAMIC: In this mode, tf.data service divides the dataset into two components:\na source component that generates \"splits\" such as filenames, and a processing\ncomponent that takes splits and outputs dataset elements. The source component\nis executed in a centralized fashion by the tf.data service dispatcher, which\ngenerates different splits of input data. The processing component is executed\nin a parallel fashion by the tf.data service workers, each operating on a\ndifferent set of input data splits.\n\nFor example, consider the following dataset:\n\n```\ndataset = tf.data.Dataset.from_tensor_slices(filenames)\ndataset = dataset.interleave(TFRecordDataset)\ndataset = dataset.map(preprocess_fn)\ndataset = dataset.batch(batch_size)\ndataset = dataset.apply(\n tf.data.experimental.service.distribute(\n processing_mode=tf.data.experimental.service.ShardingPolicy.DYNAMIC,\n ...))\n```\n\nThe `from_tensor_slices` will be run on the dispatcher, while the `interleave`,\n`map`, and `batch` will be run on tf.data service workers. The workers will pull\nfilenames from the dispatcher for processing. To process a dataset with\ndynamic sharding, the dataset must have a splittable source, and all of\nits transformations must be compatible with splitting. While most sources and\ntransformations support splitting, there are exceptions, such as custom datasets\nwhich may not implement the splitting API. Please file a Github issue if you\nwould like to use distributed epoch processing for a currently unsupported\ndataset source or transformation.\n\nIf no workers are restarted during training, dynamic sharding mode will visit\nevery example exactly once. If workers are restarted during training, the splits\nthey were processing will not be fully visited. The dispatcher maintains a\ncursor through the dataset's splits. Assuming fault tolerance is enabled (See\n\"Fault Tolerance\" below), the dispatcher will store cursor state in write-ahead\nlogs so that the cursor can be restored in case the dispatcher is restarted\nmid-training. This provides an at-most-once visitation guarantee in the presence\nof server restarts.\n\n#### Static Sharding\n\nThe following are static sharding policies. The semantics are similar to\n`tf.data.experimental.AutoShardPolicy`. These policies require:\n\n * The tf.data service cluster is configured with a fixed list of workers\n in DispatcherConfig.\n * Each client only reads from the local tf.data service worker.\n\nIf a worker is restarted while performing static sharding, the worker will\nbegin processing its shard again from the beginning.\n\nFILE: Shards by input files (i.e. each worker will get a fixed set of files to\nprocess). When this option is selected, make sure that there is at least as\nmany files as workers. If there are fewer input files than workers, a runtime\nerror will be raised.\n\nDATA: Shards by elements produced by the dataset. Each worker will process the\nwhole dataset and discard the portion that is not for itself. Note that for\nthis mode to correctly partition the dataset elements, the dataset needs to\nproduce elements in a deterministic order.\n\nFILE_OR_DATA: Attempts FILE-based sharding, falling back to DATA-based\nsharding on failure.\n\nHINT: Looks for the presence of `shard(SHARD_HINT, ...)` which is treated as a\nplaceholder to replace with `shard(num_workers, worker_index)`.\n\nFor backwards compatibility, `processing_mode` may also be set to the strings\n`\"parallel_epochs\"` or `\"distributed_epoch\"`, which are respectively equivalent\nto `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.\n\n### Coordinated Data Read\n\nBy default, when multiple consumers read from the same job, they receive data on\na first-come first-served basis. In some use cases, it is advantageous to\ncoordinate the consumers. At each step, consumers read data from the same\nworker.\n\nFor example, the tf.data service can be used to coordinate example sizes across\na cluster during synchronous training, so that during each step all replicas\ntrain on similar-sized elements. To achieve this, define a dataset which\ngenerates rounds of `num_consumers` consecutive similar-sized batches, then\nenable coordinated reads by setting `consumer_index` and `num_consumers`.\n\nNOTE: To keep consumers in sync, coordinated reads require that the dataset have\ninfinite cardinality. You can get this by adding `.repeat()` at the end of the\ndataset definition.\n\n### Jobs\n\nA tf.data service \"job\" refers to the process of reading from a dataset managed\nby the tf.data service, using one or more data consumers. Jobs are created when\niterating over datasets that read from tf.data service. The data produced by a\njob is determined by (1) dataset associated with the job and (2) the job's\nprocessing mode. For example, if a job is created for the dataset\n`Dataset.range(5)`, and the processing mode is `ShardingPolicy.OFF`, each\ntf.data worker will produce the elements `{0, 1, 2, 3, 4}` for the job,\nresulting in the\njob producing `5 * num_workers` elements. If the processing mode is\n`ShardingPolicy.DYNAMIC`, the job will only produce `5` elements.\n\nOne or more consumers can consume data from a job. By default, jobs are\n\"anonymous\", meaning that only the consumer which created the job can read from\nit. To share the output of a job across multiple consumers, you can set a common\n`job_name`.\n\n### Fault Tolerance\n\nBy default, the tf.data dispatch server stores its state in-memory, making it a\nsingle point of failure during training. To avoid this, pass\n`fault_tolerant_mode=True` when creating your `DispatchServer`. Dispatcher\nfault tolerance requires `work_dir` to be configured and accessible from the\ndispatcher both before and after restart (e.g. a GCS path). With fault tolerant\nmode enabled, the dispatcher will journal its state to the work directory so\nthat no state is lost when the dispatcher is restarted.\n\nWorkerServers may be freely restarted, added, or removed during training. At\nstartup, workers will register with the dispatcher and begin processing all\noutstanding jobs from the beginning.\n\n### Usage with tf.distribute\n\ntf.distribute is the TensorFlow API for distributed training. There are\nseveral ways to use tf.data with tf.distribute:\n`strategy.experimental_distribute_dataset`,\n`strategy.distribute_datasets_from_function`, and (for PSStrategy)\n`coordinator.create_per_worker_dataset`. The following sections give code\nexamples for each.\n\nIn general we recommend using\n`tf.data.experimental.service.{register_dataset,from_dataset_id}` over\n`tf.data.experimental.service.distribute` for two reasons:\n\n- The dataset only needs to be constructed and optimized once, instead of once\n per worker. This can significantly reduce startup time, because the current\n `experimental_distribute_dataset` and `distribute_datasets_from_function`\n implementations create and optimize worker datasets sequentially.\n- If a dataset depends on lookup tables or variables that are only present on\n one host, the dataset needs to be registered from that host. Typically this\n only happens when resources are placed on the chief or worker 0. Registering\n the dataset from the chief will avoid issues with depending on remote\n resources.\n\n#### strategy.experimental_distribute_dataset\n\nNothing special is required when using\n`strategy.experimental_distribute_dataset`, just apply `register_dataset` and\n`from_dataset_id` as above, making sure to specify a `job_name` so that all\nworkers consume from the same tf.data service job.\n\n```\ndataset = ... # Define your dataset here.\ndataset_id = tf.data.experimental.service.register_dataset(\n service=FLAGS.tf_data_service_address,\n dataset=dataset)\ndataset = tf.data.experimental.service.from_dataset_id(\n processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n service=FLAGS.tf_data_service_address,\n dataset_id=dataset_id,\n job_name=\"shared_job\")\n\ndataset = strategy.experimental_distribute_dataset(dataset)\n```\n\n#### strategy.distribute_datasets_from_function\n\nFirst, make sure the dataset produced by the `dataset_fn` does not depend on the\n`input_context` for the training worker on which it is run. Instead of each\nworker building its own (sharded) dataset, one worker should register an\nunsharded dataset, and the remaining workers should consume data from that\ndataset.\n\n```\ndataset = dataset_fn()\ndataset_id = tf.data.experimental.service.register_dataset(\n service=FLAGS.tf_data_service_address,\n dataset=dataset)\n\ndef new_dataset_fn(input_context):\n del input_context\n return tf.data.experimental.service.from_dataset_id(\n processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n service=FLAGS.tf_data_service_address,\n dataset_id=dataset_id,\n job_name=\"shared_job\")\n\ndataset = strategy.distribute_datasets_from_function(new_dataset_fn)\n```\n\n#### coordinator.create_per_worker_dataset\n\n`create_per_worker_dataset` works the same as\n`distribute_datasets_from_function`.\n\n```\ndataset = dataset_fn()\ndataset_id = tf.data.experimental.service.register_dataset(\n service=FLAGS.tf_data_service_address,\n dataset=dataset)\n\ndef new_dataset_fn(input_context):\n del input_context\n return tf.data.experimental.service.from_dataset_id(\n processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,\n service=FLAGS.tf_data_service_address,\n dataset_id=dataset_id,\n job_name=\"shared_job\")\n\ndataset = coordinator.create_per_worker_dataset(new_dataset_fn)\n```\n\n## Limitations\n\n- Python-based data processing: Datasets which use Python-based data processing\n (e.g. `tf.py_function`, `tf.numpy_function`, or\n `tf.data.Dataset.from_generator`) are currently not supported.\n- Non-Serializable Resources: Datasets may only depend on TF resources that\n support serialization. Serialization is currently supported for lookup\n tables and variables. If your dataset depends on a TF resource that cannot be\n serialized, please file a Github issue.\n- Remote Resources: If a dataset depends on a resource, the dataset must be\n registered from the same process that created the resource (e.g. the \"chief\"\n job of ParameterServerStrategy).\n\n", "desc": "API for using the tf.data service.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service.DispatcherConfig", "docs": "Configuration class for tf.data service dispatchers.\n\n Fields:\n port: Specifies the port to bind to. A value of 0 indicates that the server\n may bind to any available port.\n protocol: The protocol to use for communicating with the tf.data service,\n e.g. \"grpc\".\n work_dir: A directory to store dispatcher state in. This\n argument is required for the dispatcher to be able to recover from\n restarts.\n fault_tolerant_mode: Whether the dispatcher should write its state to a\n journal so that it can recover from restarts. Dispatcher state, including\n registered datasets and created jobs, is synchronously written to the\n journal before responding to RPCs. If `True`, `work_dir` must also be\n specified.\n worker_addresses: If the job uses auto-sharding, it needs to specify a fixed\n list of worker addresses that will register with the dispatcher. The\n worker addresses should be in the format `\"host\"` or `\"host:port\"`, where\n `\"port\"` is an integer, named port, or `%port%` to match any port.\n job_gc_check_interval_ms: How often the dispatcher should scan through to\n delete old and unused jobs, in milliseconds. If not set, the runtime will\n select a reasonable default. A higher value will reduce load on the\n dispatcher, while a lower value will reduce the time it takes for the\n dispatcher to garbage collect expired jobs.\n job_gc_timeout_ms: How long a job needs to be unused before it becomes a\n candidate for garbage collection, in milliseconds. A value of -1 indicates\n that jobs should never be garbage collected. If not set, the runtime will\n select a reasonable default. A higher value will cause jobs to stay around\n longer with no consumers. This is useful if there is a large gap in\n time between when consumers read from the job. A lower value will reduce\n the time it takes to reclaim the resources from expired jobs.\n ", "desc": "Configuration class for tf.data service dispatchers.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service.distribute", "docs": "A transformation that moves dataset processing to the tf.data service.\n\n When you iterate over a dataset containing the `distribute` transformation,\n the tf.data service creates a \"job\" which produces data for the dataset\n iteration.\n\n The tf.data service uses a cluster of workers to prepare data for training\n your model.\n The `processing_mode` argument to `tf.data.experimental.service.distribute`\n describes how to leverage multiple workers to process the input dataset.\n Currently, there are two processing modes to choose from: \"distributed_epoch\"\n and \"parallel_epochs\".\n\n \"distributed_epoch\" means that the dataset will be split across all tf.data\n service workers.\n The dispatcher produces \"splits\" for the dataset and sends them to workers for\n further processing. For example, if a dataset begins with a list of filenames,\n the dispatcher will iterate through the filenames and send the filenames to\n tf.data workers, which will perform the rest of the dataset transformations on\n those files. \"distributed_epoch\" is useful when your model needs to see each\n element of the dataset exactly once, or if it needs to see the data in a\n generally-sequential order. \"distributed_epoch\" only works for datasets with\n splittable sources, such as `Dataset.from_tensor_slices`,\n `Dataset.list_files`, or `Dataset.range`.\n\n \"parallel_epochs\" means that the entire input dataset will be processed\n independently by each of the tf.data service workers.\n For this reason, it is important to shuffle data (e.g. filenames)\n non-deterministically, so that each worker will process the elements of the\n dataset in a different order. \"parallel_epochs\" can be used to distribute\n datasets that aren't splittable.\n\n With two workers, \"parallel_epochs\" will produce every element of the dataset\n twice:\n\n >>> dispatcher = tf.data.experimental.service.DispatchServer()\n >>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n >>> # Start two workers\n >>> workers = [\n ... tf.data.experimental.service.WorkerServer(\n ... tf.data.experimental.service.WorkerConfig(\n ... dispatcher_address=dispatcher_address)) for _ in range(2)\n ... ]\n >>> dataset = tf.data.Dataset.range(10)\n >>> dataset = dataset.apply(tf.data.experimental.service.distribute(\n ... processing_mode=\"parallel_epochs\", service=dispatcher.target))\n >>> print(sorted(list(dataset.as_numpy_iterator())))\n [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]\n\n \"distributed_epoch\", on the other hand, will still produce each element once:\n\n >>> dispatcher = tf.data.experimental.service.DispatchServer()\n >>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n >>> workers = [\n ... tf.data.experimental.service.WorkerServer(\n ... tf.data.experimental.service.WorkerConfig(\n ... dispatcher_address=dispatcher_address)) for _ in range(2)\n ... ]\n >>> dataset = tf.data.Dataset.range(10)\n >>> dataset = dataset.apply(tf.data.experimental.service.distribute(\n ... processing_mode=\"distributed_epoch\", service=dispatcher.target))\n >>> print(sorted(list(dataset.as_numpy_iterator())))\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n When using `apply(tf.data.experimental.service.distribute(...))`, the dataset\n before the `apply` transformation executes within the tf.data service, while\n the operations after `apply` happen within the local process.\n\n >>> dispatcher = tf.data.experimental.service.DispatchServer()\n >>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n >>> workers = [\n ... tf.data.experimental.service.WorkerServer(\n ... tf.data.experimental.service.WorkerConfig(\n ... dispatcher_address=dispatcher_address)) for _ in range(2)\n ... ]\n >>> dataset = tf.data.Dataset.range(5)\n >>> dataset = dataset.map(lambda x: x*x)\n >>> dataset = dataset.apply(\n ... tf.data.experimental.service.distribute(\"parallel_epochs\",\n ... dispatcher.target))\n >>> dataset = dataset.map(lambda x: x+1)\n >>> print(sorted(list(dataset.as_numpy_iterator())))\n [1, 1, 2, 2, 5, 5, 10, 10, 17, 17]\n\n In the above example, the dataset operations (before applying the `distribute`\n function on the elements) will be executed on the tf.data workers,\n and the elements are provided over RPC. The remaining transformations\n (after the call to `distribute`) will be executed locally. The dispatcher\n and the workers will bind to usused free ports (which are chosen at random),\n in order to communicate with each other. However, to bind them to specific\n ports, the `port` parameter can be passed.\n\n The `job_name` argument allows jobs to be shared across multiple\n datasets. Instead of each dataset creating its own job, all\n datasets with the same `job_name` will consume from the same job. A new job\n will be created for each iteration of the dataset (with each repetition of\n `Dataset.repeat` counting as a new iteration). Suppose the `DispatchServer`\n is serving on `localhost:5000` and two training workers (in either a single\n client or multi-client setup) iterate over the below dataset, and there is a\n single tf.data worker:\n\n ```\n range5_dataset = tf.data.Dataset.range(5)\n dataset = range5_dataset.apply(tf.data.experimental.service.distribute(\n \"parallel_epochs\", \"localhost:5000\", job_name=\"my_job_name\"))\n for iteration in range(3):\n print(list(dataset))\n ```\n\n The elements of each job will be split between the two processes, with\n elements being consumed by the processes on a first-come first-served basis.\n One possible result is that process 1 prints\n\n ```\n [0, 2, 4]\n [0, 1, 3]\n [1]\n ```\n\n and process 2 prints\n\n ```\n [1, 3]\n [2, 4]\n [0, 2, 3, 4]\n ```\n\n Job names must not be re-used across different training jobs within the\n lifetime of the tf.data service. In general, the tf.data service is expected\n to live for the duration of a single training job.\n To use the tf.data service with multiple training jobs, make sure to use\n different job names to avoid conflicts. For example, suppose a training job\n calls `distribute` with `job_name=\"job\"` and reads until end of input. If\n another independent job connects to the same tf.data service and tries to read\n from `job_name=\"job\"`, it will immediately receive end of input, without\n getting any data.\n\n **Coordinated data read**\n\n By default, when multiple consumers read from the same job, they receive data\n on a first-come first-served basis. In some use cases, it is advantageous to\n coordinate the consumers. At each step, consumers read data from the same\n worker.\n\n For example, the tf.data service can be used to coordinate example sizes\n across a cluster during synchronous training, so that during each step all\n replicas train on similar-sized elements. To achieve this, define a dataset\n which generates rounds of `num_consumers` consecutive similar-sized batches,\n then enable coordinated reads by setting `consumer_index` and `num_consumers`.\n\n NOTE: To keep consumers in sync, round robin data consumption requires that\n the dataset have infinite cardinality. You can get this by adding `.repeat()`\n at the end of the dataset definition.\n\n **Keras and Distribution Strategies**\n\n The dataset produced by the `distribute` transformation can be passed to\n Keras' `Model.fit` or Distribution Strategy's\n `tf.distribute.Strategy.experimental_distribute_dataset` like any other\n `tf.data.Dataset`. We recommend setting a `job_name` on the call to\n `distribute` so that if there are multiple workers, they read data from the\n same job. Note that the autosharding normally performed by\n `experimental_distribute_dataset` will be disabled when setting a `job_name`,\n since sharing the job already results in splitting data across the workers.\n When using a shared job, data will be dynamically balanced across workers, so\n that they reach end of input about the same time. This results in better\n worker utilization than with autosharding, where each worker processes an\n independent set of files, and some workers may run out of data earlier than\n others.\n\n Args:\n processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying\n how to shard the dataset among tf.data workers. See\n `tf.data.experimental.service.ShardingPolicy` for details. For backwards\n compatibility, `processing_mode` may also be set to the strings\n `\"parallel_epochs\"` or `\"distributed_epoch\"`, which are respectively\n equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.\n service: A string or a tuple indicating how to connect to the tf.data\n service. If it's a string, it should be in the format\n `[://]`, where `` identifies the dispatcher\n address and `` can optionally be used to override the default\n protocol to use. If it's a tuple, it should be (protocol, address).\n job_name: (Optional.) The name of the job. If provided, it must be a\n non-empty string. This argument makes it possible for multiple datasets to\n share the same job. The default behavior is that the dataset creates\n anonymous, exclusively owned jobs.\n consumer_index: (Optional.) The index of the consumer in the range from `0`\n to `num_consumers`. Must be specified alongside `num_consumers`. When\n specified, consumers will read from the job in a strict round-robin order,\n instead of the default first-come-first-served order.\n num_consumers: (Optional.) The number of consumers which will consume from\n the job. Must be specified alongside `consumer_index`. When specified,\n consumers will read from the job in a strict round-robin order, instead of\n the default first-come-first-served order. When `num_consumers` is\n specified, the dataset must have infinite cardinality to prevent a\n producer from running out of data early and causing consumers to go out of\n sync.\n max_outstanding_requests: (Optional.) A limit on how many elements may be\n requested at the same time. You can use this option to control the amount\n of memory used, since `distribute` won't use more than `element_size` *\n `max_outstanding_requests` of memory.\n data_transfer_protocol: (Optional.) The protocol to use for transferring\n data with the tf.data service. By default, data is transferred using gRPC.\n compression: How to compress the dataset's elements before transferring them\n over the network. \"AUTO\" leaves the decision of how to compress up to the\n tf.data service runtime. `None` indicates not to compress.\n target_workers: (Optional.) Which workers to read from. If `\"AUTO\"`, tf.data\n runtime decides which workers to read from. If `\"ANY\"`, reads from any\n tf.data service workers. If `\"LOCAL\"`, only reads from local in-processs\n tf.data service workers. `\"AUTO\"` works well for most cases, while users\n can specify other targets. For example, `\"LOCAL\"` helps avoid RPCs and\n data copy if every TF worker colocates with a tf.data service worker.\n Consumers of a shared job must use the same `target_workers`. Defaults to\n `\"AUTO\"`.\n\n Returns:\n Dataset: A `Dataset` of the elements produced by the data service.\n ", "desc": "A transformation that moves dataset processing to the tf.data service.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service.from_dataset_id", "docs": "Creates a dataset which reads data from the tf.data service.\n\n This is useful when the dataset is registered by one process, then used in\n another process. When the same process is both registering and reading from\n the dataset, it is simpler to use `tf.data.experimental.service.distribute`\n instead.\n\n Before using `from_dataset_id`, the dataset must have been registered with the\n tf.data service using `tf.data.experimental.service.register_dataset`.\n `register_dataset` returns a dataset id for the registered dataset. That is\n the `dataset_id` which should be passed to `from_dataset_id`.\n\n The `element_spec` argument indicates the `tf.TypeSpec`s for the elements\n produced by the dataset. Currently `element_spec` must be explicitly\n specified, and match the dataset registered under `dataset_id`. `element_spec`\n defaults to `None` so that in the future we can support automatically\n discovering the `element_spec` by querying the tf.data service.\n\n `tf.data.experimental.service.distribute` is a convenience method which\n combines `register_dataset` and `from_dataset_id` into a dataset\n transformation.\n See the documentation for `tf.data.experimental.service.distribute` for more\n detail about how `from_dataset_id` works.\n\n >>> dispatcher = tf.data.experimental.service.DispatchServer()\n >>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n >>> worker = tf.data.experimental.service.WorkerServer(\n ... tf.data.experimental.service.WorkerConfig(\n ... dispatcher_address=dispatcher_address))\n >>> dataset = tf.data.Dataset.range(10)\n >>> dataset_id = tf.data.experimental.service.register_dataset(\n ... dispatcher.target, dataset)\n >>> dataset = tf.data.experimental.service.from_dataset_id(\n ... processing_mode=\"parallel_epochs\",\n ... service=dispatcher.target,\n ... dataset_id=dataset_id,\n ... element_spec=dataset.element_spec)\n >>> print(list(dataset.as_numpy_iterator()))\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n Args:\n processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying\n how to shard the dataset among tf.data workers. See\n `tf.data.experimental.service.ShardingPolicy` for details. For backwards\n compatibility, `processing_mode` may also be set to the strings\n `\"parallel_epochs\"` or `\"distributed_epoch\"`, which are respectively\n equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.\n service: A string or a tuple indicating how to connect to the tf.data\n service. If it's a string, it should be in the format\n `[://]`, where `` identifies the dispatcher\n address and `` can optionally be used to override the default\n protocol to use. If it's a tuple, it should be (protocol, address).\n dataset_id: The id of the dataset to read from. This id is returned by\n `register_dataset` when the dataset is registered with the tf.data\n service.\n element_spec: A nested structure of `tf.TypeSpec`s representing the type of\n elements produced by the dataset. This argument is only required inside a\n tf.function. Use `tf.data.Dataset.element_spec` to get the element spec\n for a given dataset.\n job_name: (Optional.) The name of the job. If provided, it must be a\n non-empty string. This argument makes it possible for multiple datasets to\n share the same job. The default behavior is that the dataset creates\n anonymous, exclusively owned jobs.\n consumer_index: (Optional.) The index of the consumer in the range from `0`\n to `num_consumers`. Must be specified alongside `num_consumers`. When\n specified, consumers will read from the job in a strict round-robin order,\n instead of the default first-come-first-served order.\n num_consumers: (Optional.) The number of consumers which will consume from\n the job. Must be specified alongside `consumer_index`. When specified,\n consumers will read from the job in a strict round-robin order, instead of\n the default first-come-first-served order. When `num_consumers` is\n specified, the dataset must have infinite cardinality to prevent a\n producer from running out of data early and causing consumers to go out of\n sync.\n max_outstanding_requests: (Optional.) A limit on how many elements may be\n requested at the same time. You can use this option to control the amount\n of memory used, since `distribute` won't use more than `element_size` *\n `max_outstanding_requests` of memory.\n data_transfer_protocol: (Optional.) The protocol to use for transferring\n data with the tf.data service. By default, data is transferred using gRPC.\n target_workers: (Optional.) Which workers to read from. If `\"AUTO\"`, tf.data\n runtime decides which workers to read from. If `\"ANY\"`, reads from any\n tf.data service workers. If `\"LOCAL\"`, only reads from local in-processs\n tf.data service workers. `\"AUTO\"` works well for most cases, while users\n can specify other targets. For example, `\"LOCAL\"` helps avoid RPCs and\n data copy if every TF worker colocates with a tf.data service worker.\n Consumers of a shared job must use the same `target_workers`. Defaults to\n `\"AUTO\"`.\n\n Returns:\n A `tf.data.Dataset` which reads from the tf.data service.\n ", "desc": "Creates a dataset which reads data from the tf.data service.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service.register_dataset", "docs": "Registers a dataset with the tf.data service.\n\n `register_dataset` registers a dataset with the tf.data service so that\n datasets can be created later with\n `tf.data.experimental.service.from_dataset_id`. This is useful when the\n dataset\n is registered by one process, then used in another process. When the same\n process is both registering and reading from the dataset, it is simpler to use\n `tf.data.experimental.service.distribute` instead.\n\n If the dataset is already registered with the tf.data service,\n `register_dataset` returns the already-registered dataset's id.\n\n >>> dispatcher = tf.data.experimental.service.DispatchServer()\n >>> dispatcher_address = dispatcher.target.split(\"://\")[1]\n >>> worker = tf.data.experimental.service.WorkerServer(\n ... tf.data.experimental.service.WorkerConfig(\n ... dispatcher_address=dispatcher_address))\n >>> dataset = tf.data.Dataset.range(10)\n >>> dataset_id = tf.data.experimental.service.register_dataset(\n ... dispatcher.target, dataset)\n >>> dataset = tf.data.experimental.service.from_dataset_id(\n ... processing_mode=\"parallel_epochs\",\n ... service=dispatcher.target,\n ... dataset_id=dataset_id,\n ... element_spec=dataset.element_spec)\n >>> print(list(dataset.as_numpy_iterator()))\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n Args:\n service: A string or a tuple indicating how to connect to the tf.data\n service. If it's a string, it should be in the format\n `[://]`, where `` identifies the dispatcher\n address and `` can optionally be used to override the default\n protocol to use. If it's a tuple, it should be (protocol, address).\n dataset: A `tf.data.Dataset` to register with the tf.data service.\n compression: (Optional.) How to compress the dataset's elements before\n transferring them over the network. \"AUTO\" leaves the decision of how to\n compress up to the tf.data service runtime. `None` indicates not to\n compress.\n\n Returns:\n A scalar int64 tensor of the registered dataset's id.\n ", "desc": "Registers a dataset with the tf.data service.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.service.WorkerConfig", "docs": "Configuration class for tf.data service dispatchers.\n\n Fields:\n dispatcher_address: Specifies the address of the dispatcher.\n worker_address: Specifies the address of the worker server. This address is\n passed to the dispatcher so that the dispatcher can tell clients how to\n connect to this worker.\n port: Specifies the port to bind to. A value of 0 indicates that the worker\n can bind to any available port.\n protocol: (Optional.) Specifies the protocol to be used by the server, e.g.\n \"grpc\".\n heartbeat_interval_ms: How often the worker should heartbeat to the\n dispatcher, in milliseconds. If not set, the runtime will select a\n reasonable default. A higher value will reduce the load on the dispatcher,\n while a lower value will reduce the time it takes to reclaim resources\n from finished jobs.\n dispatcher_timeout_ms: How long, in milliseconds, to retry requests to the\n dispatcher before giving up and reporting an error. Defaults to 1 hour.\n ", "desc": "Configuration class for tf.data service dispatchers.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.shuffle_and_repeat", "docs": "Shuffles and repeats a Dataset, reshuffling with each repetition. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.shuffle(buffer_size, seed)` followed by `tf.data.Dataset.repeat(count)`. Static tf.data optimizations will take care of using the fused implementation.\n\n>>> d = tf.data.Dataset.from_tensor_slices([1, 2, 3])\n>>> d = d.apply(tf.data.experimental.shuffle_and_repeat(2, count=2))\n>>> [elem.numpy() for elem in d] # doctest: +SKIP\n[2, 3, 1, 1, 3, 2]\n\n```python\ndataset.apply(\n tf.data.experimental.shuffle_and_repeat(buffer_size, count, seed))\n```\n\nproduces the same output as\n\n```python\ndataset.shuffle(\n buffer_size, seed=seed, reshuffle_each_iteration=True).repeat(count)\n```\n\nIn each repetition, this dataset fills a buffer with `buffer_size` elements,\nthen randomly samples elements from this buffer, replacing the selected\nelements with new elements. For perfect shuffling, set the buffer size equal\nto the full size of the dataset.\n\nFor instance, if your dataset contains 10,000 elements but `buffer_size` is\nset to 1,000, then `shuffle` will initially select a random element from\nonly the first 1,000 elements in the buffer. Once an element is selected,\nits space in the buffer is replaced by the next (i.e. 1,001-st) element,\nmaintaining the 1,000 element buffer.\n\nArgs:\n buffer_size: A `tf.int64` scalar `tf.Tensor`, representing the maximum\n number elements that will be buffered when prefetching.\n count: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the number\n of times the dataset should be repeated. The default behavior (if `count`\n is `None` or `-1`) is for the dataset be repeated indefinitely.\n seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random\n seed that will be used to create the distribution. See\n `tf.random.set_seed` for behavior.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "Shuffles and repeats a Dataset, reshuffling with each repetition. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.snapshot", "docs": "API to persist the output of the input dataset. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.snapshot(...)`.\n\nThe snapshot API allows users to transparently persist the output of their\npreprocessing pipeline to disk, and materialize the pre-processed data on a\ndifferent training run.\n\nThis API enables repeated preprocessing steps to be consolidated, and allows\nre-use of already processed data, trading off disk storage and network\nbandwidth for freeing up more valuable CPU resources and accelerator compute\ntime.\n\nhttps://github.com/tensorflow/community/blob/master/rfcs/20200107-tf-data-snapshot.md\nhas detailed design documentation of this feature.\n\nUsers can specify various options to control the behavior of snapshot,\nincluding how snapshots are read from and written to by passing in\nuser-defined functions to the `reader_func` and `shard_func` parameters.\n\n`shard_func` is a user specified function that maps input elements to snapshot\nshards.\n\nUsers may want to specify this function to control how snapshot files should\nbe written to disk. Below is an example of how a potential shard_func could\nbe written.\n\n```python\ndataset = ...\ndataset = dataset.enumerate()\ndataset = dataset.apply(tf.data.experimental.snapshot(\"/path/to/snapshot/dir\",\n shard_func=lambda x, y: x % NUM_SHARDS, ...))\ndataset = dataset.map(lambda x, y: y)\n```\n\n`reader_func` is a user specified function that accepts a single argument:\n(1) a Dataset of Datasets, each representing a \"split\" of elements of the\noriginal dataset. The cardinality of the input dataset matches the\nnumber of the shards specified in the `shard_func` (see above). The function\nshould return a Dataset of elements of the original dataset.\n\nUsers may want specify this function to control how snapshot files should be\nread from disk, including the amount of shuffling and parallelism.\n\nHere is an example of a standard reader function a user can define. This\nfunction enables both dataset shuffling and parallel reading of datasets:\n\n```python\ndef user_reader_func(datasets):\n # shuffle the datasets splits\n datasets = datasets.shuffle(NUM_CORES)\n # read datasets in parallel and interleave their elements\n return datasets.interleave(lambda x: x, num_parallel_calls=AUTOTUNE)\n\ndataset = dataset.apply(tf.data.experimental.snapshot(\"/path/to/snapshot/dir\",\n reader_func=user_reader_func))\n```\n\nBy default, snapshot parallelizes reads by the number of cores available on\nthe system, but will not attempt to shuffle the data.\n\nArgs:\n path: Required. A directory to use for storing / loading the snapshot to /\n from.\n compression: Optional. The type of compression to apply to the snapshot\n written to disk. Supported options are `GZIP`, `SNAPPY`, `AUTO` or None.\n Defaults to AUTO, which attempts to pick an appropriate compression\n algorithm for the dataset.\n reader_func: Optional. A function to control how to read data from snapshot\n shards.\n shard_func: Optional. A function to control how to shard data when writing a\n snapshot.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "API to persist the output of the input dataset. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.SparseTensorStructure", "docs": "DEPRECATED FUNCTION\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.SparseTensorSpec` instead.", "desc": "DEPRECATED FUNCTION", "type": "API"}, {"name": "tf.compat.v1.data.experimental.SqlDataset", "docs": "A `Dataset` consisting of the results from a SQL query.", "desc": "A `Dataset` consisting of the results from a SQL query.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.Structure", "docs": "Specifies a TensorFlow value type.\n\n A `tf.TypeSpec` provides metadata describing an object accepted or returned\n by TensorFlow APIs. Concrete subclasses, such as `tf.TensorSpec` and\n `tf.RaggedTensorSpec`, are used to describe different value types.\n\n For example, `tf.function`'s `input_signature` argument accepts a list\n (or nested structure) of `TypeSpec`s.\n\n Creating new subclasses of `TypeSpec` (outside of TensorFlow core) is not\n currently supported. In particular, we may make breaking changes to the\n private methods and properties defined by this base class.\n\n Example:\n\n >>> spec = tf.RaggedTensorSpec(shape=[None, None], dtype=tf.int32)\n >>> @tf.function(input_signature=[spec])\n ... def double(x):\n ... return x * 2\n >>> print(double(tf.ragged.constant([[1, 2], [3]])))\n \n ", "desc": "Specifies a TensorFlow value type.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.take_while", "docs": "A transformation that stops dataset iteration based on a `predicate`. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.take_while(...)\n\nArgs:\n predicate: A function that maps a nested structure of tensors (having shapes\n and types defined by `self.output_shapes` and `self.output_types`) to a\n scalar `tf.bool` tensor.\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "A transformation that stops dataset iteration based on a `predicate`. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.TensorArrayStructure", "docs": "DEPRECATED FUNCTION\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.TensorArraySpec` instead.", "desc": "DEPRECATED FUNCTION", "type": "API"}, {"name": "tf.compat.v1.data.experimental.TensorStructure", "docs": "DEPRECATED FUNCTION\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.TensorSpec` instead.", "desc": "DEPRECATED FUNCTION", "type": "API"}, {"name": "tf.compat.v1.data.experimental.TFRecordWriter", "docs": "Writes a dataset to a TFRecord file. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nTo write TFRecords to disk, use `tf.io.TFRecordWriter`. To save and load the contents of a dataset, use `tf.data.experimental.save` and `tf.data.experimental.load`\n\nThe elements of the dataset must be scalar strings. To serialize dataset\nelements as strings, you can use the `tf.io.serialize_tensor` function.\n\n```python\ndataset = tf.data.Dataset.range(3)\ndataset = dataset.map(tf.io.serialize_tensor)\nwriter = tf.data.experimental.TFRecordWriter(\"/path/to/file.tfrecord\")\nwriter.write(dataset)\n```\n\nTo read back the elements, use `TFRecordDataset`.\n\n```python\ndataset = tf.data.TFRecordDataset(\"/path/to/file.tfrecord\")\ndataset = dataset.map(lambda x: tf.io.parse_tensor(x, tf.int64))\n```\n\nTo shard a `dataset` across multiple TFRecord files:\n\n```python\ndataset = ... # dataset to be written\n\ndef reduce_func(key, dataset):\n filename = tf.strings.join([PATH_PREFIX, tf.strings.as_string(key)])\n writer = tf.data.experimental.TFRecordWriter(filename)\n writer.write(dataset.map(lambda _, x: x))\n return tf.data.Dataset.from_tensors(filename)\n\ndataset = dataset.enumerate()\ndataset = dataset.apply(tf.data.experimental.group_by_window(\n lambda i, _: i % NUM_SHARDS, reduce_func, tf.int64.max\n))\n\n# Iterate through the dataset to trigger data writing.\nfor _ in dataset:\n pass\n```", "desc": "Writes a dataset to a TFRecord file. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.ThreadingOptions", "docs": "Represents options for dataset threading.\n\n You can set the threading options of a dataset through the\n `experimental_threading` property of `tf.data.Options`; the property is\n an instance of `tf.data.ThreadingOptions`.\n\n ```python\n options = tf.data.Options()\n options.threading.private_threadpool_size = 10\n dataset = dataset.with_options(options)\n ```\n ", "desc": "Represents options for dataset threading.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.to_variant", "docs": "Returns a variant representing the given dataset.\n\n Args:\n dataset: A `tf.data.Dataset`.\n\n Returns:\n A scalar `tf.variant` tensor representing the given dataset.\n ", "desc": "Returns a variant representing the given dataset.", "type": "API"}, {"name": "tf.compat.v1.data.experimental.unbatch", "docs": "Splits elements of a dataset into multiple elements on the batch dimension. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.unbatch()`.\n\nFor example, if elements of the dataset are shaped `[B, a0, a1, ...]`,\nwhere `B` may vary for each input element, then for each element in the\ndataset, the unbatched dataset will contain `B` consecutive elements\nof shape `[a0, a1, ...]`.\n\n```python\n# NOTE: The following example uses `{ ... }` to represent the contents\n# of a dataset.\na = { ['a', 'b', 'c'], ['a', 'b'], ['a', 'b', 'c', 'd'] }\n\na.unbatch() == {\n 'a', 'b', 'c', 'a', 'b', 'a', 'b', 'c', 'd'}\n```\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "Splits elements of a dataset into multiple elements on the batch dimension. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.experimental.unique", "docs": "Creates a `Dataset` from another `Dataset`, discarding duplicates. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nUse `tf.data.Dataset.unique(...)\n\nUse this transformation to produce a dataset that contains one instance of\neach unique element in the input. For example:\n\n```python\ndataset = tf.data.Dataset.from_tensor_slices([1, 37, 2, 37, 2, 1])\n\n# Using `unique()` will drop the duplicate elements.\ndataset = dataset.apply(tf.data.experimental.unique()) # ==> { 1, 37, 2 }\n```\n\nReturns:\n A `Dataset` transformation function, which can be passed to\n `tf.data.Dataset.apply`.", "desc": "Creates a `Dataset` from another `Dataset`, discarding duplicates. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.data.FixedLengthRecordDataset", "docs": "A `Dataset` of fixed-length records from one or more binary files.", "desc": "A `Dataset` of fixed-length records from one or more binary files.", "type": "API"}, {"name": "tf.compat.v1.data.get_output_classes", "docs": "Returns the output classes for elements of the input dataset / iterator.\n\n Args:\n dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`.\n\n Returns:\n A (nested) structure of Python `type` objects matching the structure of the\n dataset / iterator elements and specifying the class of the individual\n components.\n\n @compatibility(TF2)\n This is a legacy API for inspecting the type signature of dataset elements. In\n TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead.\n @end_compatibility\n ", "desc": "Returns the output classes for elements of the input dataset / iterator.", "type": "API"}, {"name": "tf.compat.v1.data.get_output_shapes", "docs": "Returns the output shapes for elements of the input dataset / iterator.\n\n Args:\n dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`.\n\n Returns:\n A (nested) structure of `tf.TensorShape` objects matching the structure of\n the dataset / iterator elements and specifying the shape of the individual\n components.\n\n @compatibility(TF2)\n This is a legacy API for inspecting the type signature of dataset elements. In\n TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead.\n @end_compatibility\n ", "desc": "Returns the output shapes for elements of the input dataset / iterator.", "type": "API"}, {"name": "tf.compat.v1.data.get_output_types", "docs": "Returns the output shapes for elements of the input dataset / iterator.\n\n Args:\n dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`.\n\n Returns:\n A (nested) structure of `tf.DType` objects matching the structure of\n dataset / iterator elements and specifying the shape of the individual\n components.\n\n @compatibility(TF2)\n This is a legacy API for inspecting the type signature of dataset elements. In\n TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead.\n @end_compatibility\n ", "desc": "Returns the output shapes for elements of the input dataset / iterator.", "type": "API"}, {"name": "tf.compat.v1.data.Iterator", "docs": "Represents the state of iterating through a `Dataset`.", "desc": "Represents the state of iterating through a `Dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.make_initializable_iterator", "docs": "Creates an iterator for elements of `dataset`.\n\n Note: The returned iterator will be in an uninitialized state,\n and you must run the `iterator.initializer` operation before using it:\n\n ```python\n dataset = ...\n iterator = tf.compat.v1.data.make_initializable_iterator(dataset)\n # ...\n sess.run(iterator.initializer)\n ```\n\n Args:\n dataset: A `tf.data.Dataset`.\n shared_name: (Optional.) If non-empty, the returned iterator will be shared\n under the given name across multiple sessions that share the same devices\n (e.g. when using a remote server).\n\n Returns:\n A `tf.data.Iterator` for elements of `dataset`.\n\n Raises:\n RuntimeError: If eager execution is enabled.\n\n @compatibility(TF2)\n This is a legacy API for consuming dataset elements and should only be used\n during transition from TF 1 to TF 2. Note that using this API should be\n a transient state of your code base as there are in general no guarantees\n about the interoperability of TF 1 and TF 2 code.\n\n In TF 2 datasets are Python iterables which means you can consume their\n elements using `for elem in dataset: ...` or by explicitly creating iterator\n via `iterator = iter(dataset)` and fetching its elements via\n `values = next(iterator)`.\n @end_compatibility\n ", "desc": "Creates an iterator for elements of `dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.make_one_shot_iterator", "docs": "Creates an iterator for elements of `dataset`.\n\n Note: The returned iterator will be initialized automatically.\n A \"one-shot\" iterator does not support re-initialization.\n\n Args:\n dataset: A `tf.data.Dataset`.\n\n Returns:\n A `tf.data.Iterator` for elements of `dataset`.\n\n @compatibility(TF2)\n This is a legacy API for consuming dataset elements and should only be used\n during transition from TF 1 to TF 2. Note that using this API should be\n a transient state of your code base as there are in general no guarantees\n about the interoperability of TF 1 and TF 2 code.\n\n In TF 2 datasets are Python iterables which means you can consume their\n elements using `for elem in dataset: ...` or by explicitly creating iterator\n via `iterator = iter(dataset)` and fetching its elements via\n `values = next(iterator)`.\n @end_compatibility\n ", "desc": "Creates an iterator for elements of `dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.Options", "docs": "Represents options for `tf.data.Dataset`.\n\n A `tf.data.Options` object can be, for instance, used to control which static\n optimizations to apply to the input pipeline graph or whether to use\n performance modeling to dynamically tune the parallelism of operations such as\n `tf.data.Dataset.map` or `tf.data.Dataset.interleave`.\n\n The options are set for the entire dataset and are carried over to datasets\n created through tf.data transformations.\n\n The options can be set by constructing an `Options` object and using the\n `tf.data.Dataset.with_options(options)` transformation, which returns a\n dataset with the options set.\n\n >>> dataset = tf.data.Dataset.range(42)\n >>> options = tf.data.Options()\n >>> options.deterministic = False\n >>> dataset = dataset.with_options(options)\n >>> print(dataset.options().deterministic)\n False\n\n Note: A known limitation of the `tf.data.Options` implementation is that the\n options are not preserved across tf.function boundaries. In particular, to\n set options for a dataset that is iterated within a tf.function, the options\n need to be set within the same tf.function.\n ", "desc": "Represents options for `tf.data.Dataset`.", "type": "API"}, {"name": "tf.compat.v1.data.TextLineDataset", "docs": "A `Dataset` comprising lines from one or more text files.", "desc": "A `Dataset` comprising lines from one or more text files.", "type": "API"}, {"name": "tf.compat.v1.data.TFRecordDataset", "docs": "A `Dataset` comprising records from one or more TFRecord files.", "desc": "A `Dataset` comprising records from one or more TFRecord files.", "type": "API"}, {"name": "tf.compat.v1.debugging", "docs": "Public API for tf.debugging namespace.\n", "desc": "Public API for tf.debugging namespace.", "type": "API"}, {"name": "tf.compat.v1.debugging.Assert", "docs": "Asserts that the given condition is true.\n\nIf `condition` evaluates to false, print the list of tensors in `data`.\n`summarize` determines how many entries of the tensors to print.\n\nArgs:\n condition: The condition to evaluate.\n data: The tensors to print out when condition is false.\n summarize: Print this many entries of each tensor.\n name: A name for this operation (optional).\n\nReturns:\n assert_op: An `Operation` that, when executed, raises a\n `tf.errors.InvalidArgumentError` if `condition` is not true.\n @compatibility(eager)\n returns None\n @end_compatibility\n\nRaises:\n @compatibility(TF1)\n When in TF V1 mode (that is, outside `tf.function`) Assert needs a control\n dependency on the output to ensure the assertion executes:\n\n```python\n# Ensure maximum element of x is smaller or equal to 1\nassert_op = tf.Assert(tf.less_equal(tf.reduce_max(x), 1.), [x])\nwith tf.control_dependencies([assert_op]):\n ... code using x ...\n```\n\n @end_compatibility\n\n\nNote: The output of this function should be used. If it is not, a warning will be logged or an error may be raised. To mark the output as used, call its .mark_used() method.", "desc": "Asserts that the given condition is true.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_all_finite", "docs": "Assert that the tensor does not contain any NaN's or Inf's.\n\n Args:\n t: Tensor to check.\n msg: Message to log on failure.\n name: A name for this operation (optional).\n x: Alias for t.\n message: Alias for msg.\n\n Returns:\n Same tensor as `t`.\n ", "desc": "Assert that the tensor does not contain any NaN's or Inf's.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_equal", "docs": "\n Assert the condition `x == y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] == y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x == y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x == y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_equal(a, b,\n ... message='\"a == b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 2]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 2], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_equal(a, b, message=\n ... '\"a == b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_greater", "docs": "\n Assert the condition `x > y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] > y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_greater(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_greater\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x > y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x > y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_greater` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_greater` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_greater(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_greater(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_greater(a, b,\n ... message='\"a > b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[0, 1]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([0, 1], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_greater(a, b, message=\n ... '\"a > b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_greater_equal", "docs": "\n Assert the condition `x >= y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] >= y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_greater_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_greater_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x >= y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x >= y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_greater_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_greater_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_greater_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_greater_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_greater_equal(a, b,\n ... message='\"a >= b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 0]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 0], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_greater_equal(a, b, message=\n ... '\"a >= b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_integer", "docs": "Assert that `x` is of integer dtype.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_integer(x)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: `Tensor` whose basetype is integer and is not quantized.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_integer\".\n\n Raises:\n TypeError: If `x.dtype` is anything other than non-quantized integer.\n\n Returns:\n A `no_op` that does nothing. Type can be determined statically.\n ", "desc": "Assert that `x` is of integer dtype.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_less", "docs": "\n Assert the condition `x < y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] < y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_less(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_less\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x < y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x < y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_less` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_less` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_less(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_less(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_less(a, b,\n ... message='\"a < b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[2, 3]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([2, 3], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_less(a, b, message=\n ... '\"a < b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_less_equal", "docs": "\n Assert the condition `x <= y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] <= y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_less_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_less_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x <= y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x <= y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_less_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_less_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_less_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_less_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_less_equal(a, b,\n ... message='\"a <= b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[1, 3]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([1, 3], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_less_equal(a, b, message=\n ... '\"a <= b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_near", "docs": "Assert the condition `x` and `y` are close element-wise.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_near(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have\n\n ```tf.abs(x[i] - y[i]) <= atol + rtol * tf.abs(y[i])```.\n\n If both `x` and `y` are empty, this is trivially satisfied.\n\n The default `atol` and `rtol` is `10 * eps`, where `eps` is the smallest\n representable positive number such that `1 + eps != 1`. This is about\n `1.2e-6` in `32bit`, `2.22e-15` in `64bit`, and `0.00977` in `16bit`.\n See `numpy.finfo`.\n\n Args:\n x: Float or complex `Tensor`.\n y: Float or complex `Tensor`, same `dtype` as, and broadcastable to, `x`.\n rtol: `Tensor`. Same `dtype` as, and broadcastable to, `x`.\n The relative tolerance. Default is `10 * eps`.\n atol: `Tensor`. Same `dtype` as, and broadcastable to, `x`.\n The absolute tolerance. Default is `10 * eps`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_near\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x` and `y` are not close enough.\n\n @compatibility(numpy)\n Similar to `numpy.testing.assert_allclose`, except tolerance depends on data\n type. This is due to the fact that `TensorFlow` is often used with `32bit`,\n `64bit`, and even `16bit` data.\n @end_compatibility\n ", "desc": "Assert the condition `x` and `y` are close element-wise.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_negative", "docs": "\n Assert the condition `x < 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_negative(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Negative means, for every element `x[i]` of `x`, we have `x[i] < 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_negative\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x < 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x < 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_non_negative", "docs": "\n Assert the condition `x >= 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_non_negative(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Non-negative means, for every element `x[i]` of `x`, we have `x[i] >= 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_non_negative\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x >= 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x >= 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_non_positive", "docs": "\n Assert the condition `x <= 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_non_positive(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Non-positive means, for every element `x[i]` of `x`, we have `x[i] <= 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_non_positive\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x <= 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x <= 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_none_equal", "docs": "\n Assert the condition `x != y` holds element-wise.\n\n This condition holds if for every pair of (possibly broadcast) elements\n `x[i]`, `y[i]`, we have `x[i] != y[i]`.\n If both `x` and `y` are empty, this is trivially satisfied.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_none_equal(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n y: Numeric `Tensor`, same dtype as and broadcastable to `x`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`, `y`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_none_equal\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x != y` is False.\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x != y` is False. The check can be performed immediately during\n eager execution or if `x` and `y` are statically known.\n\n @compatibility(TF2)\n `tf.compat.v1.assert_none_equal` is compatible with eager execution and\n `tf.function`.\n Please use `tf.debugging.assert_none_equal` instead when migrating to TF2. Apart\n from `data`, all arguments are supported with the same argument name.\n\n If you want to ensure the assert statements run before the\n potentially-invalid computation, please use `tf.control_dependencies`,\n as tf.function auto-control dependencies are insufficient for assert\n statements.\n\n #### Structural Mapping to Native TF2\n\n Before:\n\n ```python\n tf.compat.v1.assert_none_equal(\n x=x, y=y, data=data, summarize=summarize,\n message=message, name=name)\n ```\n\n After:\n\n ```python\n tf.debugging.assert_none_equal(\n x=x, y=y, message=message,\n summarize=summarize, name=name)\n ```\n\n #### TF1 & TF2 Usage Example\n\n TF1:\n\n >>> g = tf.Graph()\n >>> with g.as_default():\n ... a = tf.compat.v1.placeholder(tf.float32, [2])\n ... b = tf.compat.v1.placeholder(tf.float32, [2])\n ... result = tf.compat.v1.assert_none_equal(a, b,\n ... message='\"a != b\" does not hold for the given inputs')\n ... with tf.compat.v1.control_dependencies([result]):\n ... sum_node = a + b\n >>> sess = tf.compat.v1.Session(graph=g)\n >>> val = sess.run(sum_node, feed_dict={a: [1, 2], b:[2, 1]})\n\n\n TF2:\n\n >>> a = tf.Variable([1, 2], dtype=tf.float32)\n >>> b = tf.Variable([2, 1], dtype=tf.float32)\n >>> assert_op = tf.debugging.assert_none_equal(a, b, message=\n ... '\"a != b\" does not hold for the given inputs')\n >>> # When working with tf.control_dependencies\n >>> with tf.control_dependencies([assert_op]):\n ... val = a + b\n\n @end_compatibility\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_positive", "docs": "\n Assert the condition `x > 0` holds element-wise.\n\n When running in graph mode, you should add a dependency on this operation\n to ensure that it runs. Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.debugging.assert_positive(x, y)]):\n output = tf.reduce_sum(x)\n ```\n\n Positive means, for every element `x[i]` of `x`, we have `x[i] > 0`.\n If `x` is empty this is trivially satisfied.\n\n Args:\n x: Numeric `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_positive\".\n\n Returns:\n Op that raises `InvalidArgumentError` if `x > 0` is False.\n @compatibility(eager)\n returns None\n @end_compatibility\n\n Raises:\n InvalidArgumentError: if the check can be performed immediately and\n `x > 0` is False. The check can be performed immediately during\n eager execution or if `x` is statically known.\n ", "desc": "", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_proper_iterable", "docs": "Static assert that values is a \"proper\" iterable.\n\n `Ops` that expect iterables of `Tensor` can call this to validate input.\n Useful since `Tensor`, `ndarray`, byte/text type are all iterables themselves.\n\n Args:\n values: Object to be checked.\n\n Raises:\n TypeError: If `values` is not iterable or is one of\n `Tensor`, `SparseTensor`, `np.array`, `tf.compat.bytes_or_text_types`.\n ", "desc": "Static assert that values is a \"proper\" iterable.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_rank", "docs": "Assert `x` has rank equal to `rank`.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank(x, 2)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n rank: Scalar integer `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and the shape of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_rank\".\n\n Returns:\n Op raising `InvalidArgumentError` unless `x` has specified rank.\n If static checks determine `x` has correct rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has wrong rank.\n ", "desc": "Assert `x` has rank equal to `rank`.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_rank_at_least", "docs": "Assert `x` has rank equal to `rank` or higher.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank_at_least(x, 2)]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n rank: Scalar `Tensor`.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional).\n Defaults to \"assert_rank_at_least\".\n\n Returns:\n Op raising `InvalidArgumentError` unless `x` has specified rank or higher.\n If static checks determine `x` has correct rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has wrong rank.\n ", "desc": "Assert `x` has rank equal to `rank` or higher.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_rank_in", "docs": "Assert `x` has rank in `ranks`.\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.compat.v1.assert_rank_in(x, (2, 4))]):\n output = tf.reduce_sum(x)\n ```\n\n Args:\n x: Numeric `Tensor`.\n ranks: Iterable of scalar `Tensor` objects.\n data: The tensors to print out if the condition is False. Defaults to\n error message and first few entries of `x`.\n summarize: Print this many entries of each tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional).\n Defaults to \"assert_rank_in\".\n\n Returns:\n Op raising `InvalidArgumentError` unless rank of `x` is in `ranks`.\n If static checks determine `x` has matching rank, a `no_op` is returned.\n\n Raises:\n ValueError: If static checks determine `x` has mismatched rank.\n ", "desc": "Assert `x` has rank in `ranks`.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_same_float_dtype", "docs": "Validate and return float type based on `tensors` and `dtype`.\n\n For ops such as matrix multiplication, inputs and weights must be of the\n same float type. This function validates that all `tensors` are the same type,\n validates that type is `dtype` (if supplied), and returns the type. Type must\n be a floating point type. If neither `tensors` nor `dtype` is supplied,\n the function will return `dtypes.float32`.\n\n Args:\n tensors: Tensors of input values. Can include `None` elements, which will be\n ignored.\n dtype: Expected type.\n\n Returns:\n Validated type.\n\n Raises:\n ValueError: if neither `tensors` nor `dtype` is supplied, or result is not\n float, or the common type of the inputs is not a floating point type.\n ", "desc": "Validate and return float type based on `tensors` and `dtype`.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_scalar", "docs": "Asserts that the given `tensor` is a scalar (i.e. zero-dimensional).\n\n This function raises `ValueError` unless it can be certain that the given\n `tensor` is a scalar. `ValueError` is also raised if the shape of `tensor` is\n unknown.\n\n Args:\n tensor: A `Tensor`.\n name: A name for this operation. Defaults to \"assert_scalar\"\n message: A string to prefix to the default message.\n\n Returns:\n The input tensor (potentially converted to a `Tensor`).\n\n Raises:\n ValueError: If the tensor is not scalar (rank 0), or if its shape is\n unknown.\n ", "desc": "Asserts that the given `tensor` is a scalar (i.e. zero-dimensional).", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_shapes", "docs": "Assert tensor shapes and dimension size relationships between tensors.\n\n This Op checks that a collection of tensors shape relationships\n satisfies given constraints.\n\n Example:\n\n >>> n = 10\n >>> q = 3\n >>> d = 7\n >>> x = tf.zeros([n,q])\n >>> y = tf.ones([n,d])\n >>> param = tf.Variable([1.0, 2.0, 3.0])\n >>> scalar = 1.0\n >>> tf.debugging.assert_shapes([\n ... (x, ('N', 'Q')),\n ... (y, ('N', 'D')),\n ... (param, ('Q',)),\n ... (scalar, ()),\n ... ])\n\n >>> tf.debugging.assert_shapes([\n ... (x, ('N', 'D')),\n ... (y, ('N', 'D'))\n ... ])\n Traceback (most recent call last):\n ...\n ValueError: ...\n\n Example of adding a dependency to an operation:\n\n ```python\n with tf.control_dependencies([tf.assert_shapes(shapes)]):\n output = tf.matmul(x, y, transpose_a=True)\n ```\n\n If `x`, `y`, `param` or `scalar` does not have a shape that satisfies\n all specified constraints, `message`, as well as the first `summarize` entries\n of the first encountered violating tensor are printed, and\n `InvalidArgumentError` is raised.\n\n Size entries in the specified shapes are checked against other entries by\n their __hash__, except:\n - a size entry is interpreted as an explicit size if it can be parsed as an\n integer primitive.\n - a size entry is interpreted as *any* size if it is None or '.'.\n\n If the first entry of a shape is `...` (type `Ellipsis`) or '*' that indicates\n a variable number of outer dimensions of unspecified size, i.e. the constraint\n applies to the inner-most dimensions only.\n\n Scalar tensors and specified shapes of length zero (excluding the 'inner-most'\n prefix) are both treated as having a single dimension of size one.\n\n Args:\n shapes: A list of (`Tensor`, `shape`) tuples, wherein `shape` is the\n expected shape of `Tensor`. See the example code above. The `shape` must\n be an iterable. Each element of the iterable can be either a concrete\n integer value or a string that abstractly represents the dimension.\n For example,\n - `('N', 'Q')` specifies a 2D shape wherein the first and second\n dimensions of shape may or may not be equal.\n - `('N', 'N', 'Q')` specifies a 3D shape wherein the first and second\n dimensions are equal.\n - `(1, 'N')` specifies a 2D shape wherein the first dimension is\n exactly 1 and the second dimension can be any value.\n Note that the abstract dimension letters take effect across different\n tuple elements of the list. For example,\n `tf.debugging.assert_shapes([(x, ('N', 'A')), (y, ('N', 'B'))]` asserts\n that both `x` and `y` are rank-2 tensors and their first dimensions are\n equal (`N`).\n `shape` can also be a `tf.TensorShape`.\n data: The tensors to print out if the condition is False. Defaults to error\n message and first few entries of the violating tensor.\n summarize: Print this many entries of the tensor.\n message: A string to prefix to the default message.\n name: A name for this operation (optional). Defaults to \"assert_shapes\".\n\n Returns:\n Op raising `InvalidArgumentError` unless all shape constraints are\n satisfied.\n If static checks determine all constraints are satisfied, a `no_op` is\n returned.\n\n Raises:\n ValueError: If static checks determine any shape constraint is violated.\n ", "desc": "Assert tensor shapes and dimension size relationships between tensors.", "type": "API"}, {"name": "tf.compat.v1.debugging.assert_type", "docs": "Statically asserts that the given `Tensor` is of the specified type.\n\n Args:\n tensor: A `Tensor` or `SparseTensor`.\n tf_type: A tensorflow type (`dtypes.float32`, `tf.int64`, `dtypes.bool`,\n etc).\n message: A string to prefix to the default message.\n name: A name to give this `Op`. Defaults to \"assert_type\"\n\n Raises:\n TypeError: If the tensors data type doesn't match `tf_type`.\n\n Returns:\n A `no_op` that does nothing. Type can be determined statically.\n ", "desc": "Statically asserts that the given `Tensor` is of the specified type.", "type": "API"}, {"name": "tf.compat.v1.debugging.check_numerics", "docs": "Checks a tensor for NaN and Inf values.\n\n When run, reports an `InvalidArgument` error if `tensor` has any values\n that are not a number (NaN) or infinity (Inf). Otherwise, returns the input\n tensor.\n\n Example usage:\n\n ``` python\n a = tf.Variable(1.0)\n tf.debugging.check_numerics(a, message='')\n\n b = tf.Variable(np.nan)\n try:\n tf.debugging.check_numerics(b, message='Checking b')\n except Exception as e:\n assert \"Checking b : Tensor had NaN values\" in e.message\n\n c = tf.Variable(np.inf)\n try:\n tf.debugging.check_numerics(c, message='Checking c')\n except Exception as e:\n assert \"Checking c : Tensor had Inf values\" in e.message\n ```\n\n Args:\n tensor: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n message: A `string`. Prefix of the error message.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `tensor`.\n ", "desc": "Checks a tensor for NaN and Inf values.", "type": "API"}, {"name": "tf.compat.v1.debugging.disable_check_numerics", "docs": "Disable the eager/graph unified numerics checking mechanism.\n\n This method can be used after a call to `tf.debugging.enable_check_numerics()`\n to disable the numerics-checking mechanism that catches infinity and NaN\n values output by ops executed eagerly or in tf.function-compiled graphs.\n\n This method is idempotent. Calling it multiple times has the same effect\n as calling it once.\n\n This method takes effect only on the thread in which it is called.\n ", "desc": "Disable the eager/graph unified numerics checking mechanism.", "type": "API"}, {"name": "tf.compat.v1.debugging.enable_check_numerics", "docs": "Enable tensor numerics checking in an eager/graph unified fashion.\n\n The numerics checking mechanism will cause any TensorFlow eager execution or\n graph execution to error out as soon as an op's output tensor contains\n infinity or NaN.\n\n This method is idempotent. Calling it multiple times has the same effect\n as calling it once.\n\n This method takes effect only on the thread in which it is called.\n\n When a op's float-type output tensor contains any Infinity or NaN, an\n `tf.errors.InvalidArgumentError` will be thrown, with an error message that\n reveals the following information:\n - The type of the op that generated the tensor with bad numerics.\n - Data type (dtype) of the tensor.\n - Shape of the tensor (to the extent known at the time of eager execution\n or graph construction).\n - Name of the containing graph (if available).\n - (Graph mode only): The stack trace of the intra-graph op's creation,\n with a stack-height limit and a path-length limit for visual clarity.\n The stack frames that belong to the user's code (as opposed to\n tensorflow's internal code) are highlighted with a text arrow (\"->\").\n - (Eager mode only): How many of the offending tensor's elements are\n `Infinity` and `NaN`, respectively.\n\n Once enabled, the check-numerics mechanism can be disabled by using\n `tf.debugging.disable_check_numerics()`.\n\n Example usage:\n\n 1. Catching infinity during the execution of a `tf.function` graph:\n\n ```py\n import tensorflow as tf\n\n tf.debugging.enable_check_numerics()\n\n @tf.function\n def square_log_x_plus_1(x):\n v = tf.math.log(x + 1)\n return tf.math.square(v)\n\n x = -1.0\n\n # When the following line runs, a function graph will be compiled\n # from the Python function `square_log_x_plus_1()`. Due to the\n # `enable_check_numerics()` call above, the graph will contain\n # numerics checking ops that will run during the function graph's\n # execution. The function call generates an -infinity when the Log\n # (logarithm) op operates on the output tensor of the Add op.\n # The program errors out at this line, printing an error message.\n y = square_log_x_plus_1(x)\n z = -y\n ```\n\n 2. Catching NaN during eager execution:\n\n ```py\n import numpy as np\n import tensorflow as tf\n\n tf.debugging.enable_check_numerics()\n\n x = np.array([[0.0, -1.0], [4.0, 3.0]])\n\n # The following line executes the Sqrt op eagerly. Due to the negative\n # element in the input array, a NaN is generated. Due to the\n # `enable_check_numerics()` call above, the program errors immediately\n # at this line, printing an error message.\n y = tf.math.sqrt(x)\n z = tf.matmul(y, y)\n ```\n\n NOTE: If your code is running on TPUs, be sure to call\n `tf.config.set_soft_device_placement(True)` before calling\n `tf.debugging.enable_check_numerics()` as this API uses automatic outside\n compilation on TPUs. For example:\n\n ```py\n tf.config.set_soft_device_placement(True)\n tf.debugging.enable_check_numerics()\n\n resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n strategy = tf.distribute.TPUStrategy(resolver)\n with strategy.scope():\n # ...\n ```\n\n Args:\n stack_height_limit: Limit to the height of the printed stack trace.\n Applicable only to ops in `tf.function`s (graphs).\n path_length_limit: Limit to the file path included in the printed stack\n trace. Applicable only to ops in `tf.function`s (graphs).\n ", "desc": "Enable tensor numerics checking in an eager/graph unified fashion.", "type": "API"}, {"name": "tf.compat.v1.debugging.experimental", "docs": "Public API for tf.debugging.experimental namespace.\n", "desc": "Public API for tf.debugging.experimental namespace.", "type": "API"}, {"name": "tf.compat.v1.debugging.experimental.disable_dump_debug_info", "docs": "Disable the currently-enabled debugging dumping.\n\n If the `enable_dump_debug_info()` method under the same Python namespace\n has been invoked before, calling this method disables it. If no call to\n `enable_dump_debug_info()` has been made, calling this method is a no-op.\n Calling this method more than once is idempotent.\n ", "desc": "Disable the currently-enabled debugging dumping.", "type": "API"}, {"name": "tf.compat.v1.debugging.experimental.enable_dump_debug_info", "docs": "Enable dumping debugging information from a TensorFlow program.\n\n The debugging information is dumped to a directory on the file system\n specified as `dump_root`.\n\n The dumped debugging information can be ingested by debugger UIs.\n\n The files in the dump directory contain the following information:\n - TensorFlow Function construction (e.g., compilation of Python functions\n decorated with @tf.function), the op types, names (if available), context,\n the input and output tensors, and the associated stack traces.\n - Execution of TensorFlow operations (ops) and Functions and their stack\n traces, op types, names (if available) and contexts. In addition,\n depending on the value of the `tensor_debug_mode` argument (see Args\n section below), the value(s) of the output tensors or more concise\n summaries of the tensor values will be dumped.\n - A snapshot of Python source files involved in the execution of the\n TensorFlow program.\n\n Once enabled, the dumping can be disabled with the corresponding\n `disable_dump_debug_info()` method under the same Python namespace.\n Calling this method more than once with the same `dump_root` is idempotent.\n Calling this method more than once with different `tensor_debug_mode`s\n leads to a `ValueError`.\n Calling this method more than once with different `circular_buffer_size`s\n leads to a `ValueError`.\n Calling this method with a different `dump_root` abolishes the\n previously-enabled `dump_root`.\n\n Usage example:\n\n ```py\n tf.debugging.experimental.enable_dump_debug_info('/tmp/my-tfdbg-dumps')\n\n # Code to build, train and run your TensorFlow model...\n ```\n\n NOTE: If your code is running on TPUs, be sure to call\n `tf.config.set_soft_device_placement(True)` before calling\n `tf.debugging.experimental.enable_dump_debug_info()` as this API uses\n automatic outside compilation on TPUs. For example:\n\n ```py\n tf.config.set_soft_device_placement(True)\n tf.debugging.experimental.enable_dump_debug_info(\n logdir, tensor_debug_mode=\"FULL_HEALTH\")\n\n resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n strategy = tf.distribute.TPUStrategy(resolver)\n with strategy.scope():\n # ...\n ```\n\n Args:\n dump_root: The directory path where the dumping information will be written.\n tensor_debug_mode: Debug mode for tensor values, as a string.\n The currently supported options are:\n - \"NO_TENSOR\": (Default) Only traces the output tensors of all executed\n ops (including those executed eagerly at the Python level or as a part\n of a TensorFlow graph) and functions, while not extracting any\n information from the values of the tensors.\n - \"CURT_HEALTH\": For each floating-dtype tensor (e.g., tensors of dtypes\n such as `float32`, `float64` and `bfloat16`), extracts a binary bit\n indicating whether it contains any -infinity, +infinity or NaN.\n - \"CONCISE_HEALTH\": For each floating-dtype tensor, extract total\n element count, and counts of -infinity, +infinity and NaN elements.\n - \"FULL_HEALTH\": For each floating-dtype tensor, extracts the dtype,\n rank (number of dimensions), total element count, and counts of\n -infinity, +infinity and NaN elements.\n - \"SHAPE\": For each tensor (regardless of dtype), extracts its dtype,\n rank, total element count and shape.\n circular_buffer_size: Size of the circular buffers for execution events.\n These circular buffers are designed to reduce the overhead of debugging\n dumping. They hold the most recent debug events concerning eager execution\n of ops and `tf.function`s and traces of tensor values computed inside\n `tf.function`s. They are written to the file system only when the proper\n flushing method is called (see description of return values below).\n Expected to be an integer. If <= 0, the circular-buffer behavior will be\n disabled, i.e., the execution debug events will be written to the file\n writers in the same way as non-execution events such as op creations and\n source-file snapshots.\n op_regex: Dump data from only the tensors from op types that matches to the\n regular expression (through Python's `re.match()`).\n \"Op type\" refers to the names of the TensorFlow operations (e.g.,\n \"MatMul\", \"LogSoftmax\"), which may repeat in a TensorFlow\n function. It does *not* refer to the names of nodes (e.g.,\n \"dense/MatMul\", \"dense_1/MatMul_1\") which are unique within a function.\n - Example 1: Dump tensor data from only MatMul and Relu ops\n `op_regex=\"^(MatMul|Relu)$\"`.\n - Example 2: Dump tensors from all ops *except* Relu:\n `op_regex=\"(?!^Relu$)\"`.\n This filter operates in a logical AND relation with `tensor_dtypes`.\n tensor_dtypes: Dump data from only the tensors of which the specified\n dtypes. This optional argument can be in any of the following format:\n - a list or tuple of `DType` objects or strings that can be converted\n to `DType` objects via `tf.as_dtype()`. Examples:\n - `tensor_dtype=[tf.float32, tf.float64]`,\n - `tensor_dtype=[\"float32\", \"float64\"]`,\n - `tensor_dtypes=(tf.int32, tf.bool)`,\n - `tensor_dtypes=(\"int32\", \"bool\")`\n - a callable that takes a single `DType` argument and returns a Python\n `boolean` indicating whether the dtype is to be included in the data\n dumping. Examples:\n - `tensor_dtype=lambda dtype: dtype.is_integer`.\n This filter operates in a logical AND relation with `op_regex`.\n Returns:\n A DebugEventsWriter instance used by the dumping callback. The caller\n may use its flushing methods, including `FlushNonExecutionFiles()` and\n `FlushExecutionFiles()`.\n ", "desc": "Enable dumping debugging information from a TensorFlow program.", "type": "API"}, {"name": "tf.compat.v1.debugging.get_log_device_placement", "docs": "Get if device placements are logged.\n\n Returns:\n If device placements are logged.\n ", "desc": "Get if device placements are logged.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_finite", "docs": "Returns which elements of x are finite.\n\n @compatibility(numpy)\n Equivalent to np.isfinite\n @end_compatibility\n\n Example:\n\n ```python\n x = tf.constant([5.0, 4.8, 6.8, np.inf, np.nan])\n tf.math.is_finite(x) ==> [True, True, True, False, False]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `bool`.\n ", "desc": "Returns which elements of x are finite.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_inf", "docs": "Returns which elements of x are Inf.\n\n @compatibility(numpy)\n Equivalent to np.isinf\n @end_compatibility\n\n Example:\n\n ```python\n x = tf.constant([5.0, np.inf, 6.8, np.inf])\n tf.math.is_inf(x) ==> [False, True, False, True]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `bool`.\n ", "desc": "Returns which elements of x are Inf.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_nan", "docs": "Returns which elements of x are NaN.\n\n @compatibility(numpy)\n Equivalent to np.isnan\n @end_compatibility\n\n Example:\n\n ```python\n x = tf.constant([5.0, np.nan, 6.8, np.nan, np.inf])\n tf.math.is_nan(x) ==> [False, True, False, True, False]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `bool`.\n ", "desc": "Returns which elements of x are NaN.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_non_decreasing", "docs": "Returns `True` if `x` is non-decreasing.\n\n Elements of `x` are compared in row-major order. The tensor `[x[0],...]`\n is non-decreasing if for every adjacent pair we have `x[i] <= x[i+1]`.\n If `x` has less than two elements, it is trivially non-decreasing.\n\n See also: `is_strictly_increasing`\n\n >>> x1 = tf.constant([1.0, 1.0, 3.0])\n >>> tf.math.is_non_decreasing(x1)\n \n >>> x2 = tf.constant([3.0, 1.0, 2.0])\n >>> tf.math.is_non_decreasing(x2)\n \n\n Args:\n x: Numeric `Tensor`.\n name: A name for this operation (optional). Defaults to \"is_non_decreasing\"\n\n Returns:\n Boolean `Tensor`, equal to `True` iff `x` is non-decreasing.\n\n Raises:\n TypeError: if `x` is not a numeric tensor.\n ", "desc": "Returns `True` if `x` is non-decreasing.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_numeric_tensor", "docs": "Returns `True` if the elements of `tensor` are numbers.\n\n Specifically, returns `True` if the dtype of `tensor` is one of the following:\n\n * `tf.float16`\n * `tf.float32`\n * `tf.float64`\n * `tf.int8`\n * `tf.int16`\n * `tf.int32`\n * `tf.int64`\n * `tf.uint8`\n * `tf.uint16`\n * `tf.uint32`\n * `tf.uint64`\n * `tf.qint8`\n * `tf.qint16`\n * `tf.qint32`\n * `tf.quint8`\n * `tf.quint16`\n * `tf.complex64`\n * `tf.complex128`\n * `tf.bfloat16`\n\n Returns `False` if `tensor` is of a non-numeric type or if `tensor` is not\n a `tf.Tensor` object.\n ", "desc": "Returns `True` if the elements of `tensor` are numbers.", "type": "API"}, {"name": "tf.compat.v1.debugging.is_strictly_increasing", "docs": "Returns `True` if `x` is strictly increasing.\n\n Elements of `x` are compared in row-major order. The tensor `[x[0],...]`\n is strictly increasing if for every adjacent pair we have `x[i] < x[i+1]`.\n If `x` has less than two elements, it is trivially strictly increasing.\n\n See also: `is_non_decreasing`\n\n >>> x1 = tf.constant([1.0, 2.0, 3.0])\n >>> tf.math.is_strictly_increasing(x1)\n \n >>> x2 = tf.constant([3.0, 1.0, 2.0])\n >>> tf.math.is_strictly_increasing(x2)\n \n\n Args:\n x: Numeric `Tensor`.\n name: A name for this operation (optional).\n Defaults to \"is_strictly_increasing\"\n\n Returns:\n Boolean `Tensor`, equal to `True` iff `x` is strictly increasing.\n\n Raises:\n TypeError: if `x` is not a numeric tensor.\n ", "desc": "Returns `True` if `x` is strictly increasing.", "type": "API"}, {"name": "tf.compat.v1.debugging.set_log_device_placement", "docs": "Turns logging for device placement decisions on or off.\n\n Operations execute on a particular device, producing and consuming tensors on\n that device. This may change the performance of the operation or require\n TensorFlow to copy data to or from an accelerator, so knowing where operations\n execute is useful for debugging performance issues.\n\n For more advanced profiling, use the [TensorFlow\n profiler](https://www.tensorflow.org/guide/profiler).\n\n Device placement for operations is typically controlled by a `tf.device`\n scope, but there are exceptions, for example operations on a `tf.Variable`\n which follow the initial placement of the variable. Turning off soft device\n placement (with `tf.config.set_soft_device_placement`) provides more explicit\n control.\n\n >>> tf.debugging.set_log_device_placement(True)\n >>> tf.ones([])\n >>> # [...] op Fill in device /job:localhost/replica:0/task:0/device:GPU:0\n >>> with tf.device(\"CPU\"):\n ... tf.ones([])\n >>> # [...] op Fill in device /job:localhost/replica:0/task:0/device:CPU:0\n >>> tf.debugging.set_log_device_placement(False)\n\n Turning on `tf.debugging.set_log_device_placement` also logs the placement of\n ops inside `tf.function` when the function is called.\n\n Args:\n enabled: Whether to enabled device placement logging.\n ", "desc": "Turns logging for device placement decisions on or off.", "type": "API"}, {"name": "tf.compat.v1.decode_base64", "docs": "Decode web-safe base64-encoded strings.\n\n Input may or may not have padding at the end. See\n [EncodeBase64](https://www.tensorflow.org/api_docs/python/tf/io/encode_base64)\n for padding. Web-safe means that input must use - and _ instead of + and /.\n\n Args:\n input: A `Tensor` of type `string`. Base64 strings to decode.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Decode web-safe base64-encoded strings.", "type": "API"}, {"name": "tf.compat.v1.decode_compressed", "docs": "Decompress strings.\n\n This op decompresses each element of the `bytes` input `Tensor`, which\n is assumed to be compressed using the given `compression_type`.\n\n The `output` is a string `Tensor` of the same shape as `bytes`,\n each element containing the decompressed data from the corresponding\n element in `bytes`.\n\n Args:\n bytes: A `Tensor` of type `string`.\n A Tensor of string which is compressed.\n compression_type: An optional `string`. Defaults to `\"\"`.\n A scalar containing either (i) the empty string (no\n compression), (ii) \"ZLIB\", or (iii) \"GZIP\".\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Decompress strings.", "type": "API"}, {"name": "tf.compat.v1.decode_csv", "docs": "Convert CSV records to tensors. Each column maps to one tensor.\n\n RFC 4180 format is expected for the CSV records.\n (https://tools.ietf.org/html/rfc4180)\n Note that we allow leading and trailing spaces with int or float field.\n\n Args:\n records: A `Tensor` of type `string`.\n Each string is a record/row in the csv and all records should have\n the same format.\n record_defaults: A list of `Tensor` objects with specific types.\n Acceptable types are `float32`, `float64`, `int32`, `int64`, `string`.\n One tensor per column of the input record, with either a\n scalar default value for that column or an empty vector if the column is\n required.\n field_delim: An optional `string`. Defaults to `\",\"`.\n char delimiter to separate fields in a record.\n use_quote_delim: An optional `bool`. Defaults to `True`.\n If false, treats double quotation marks as regular\n characters inside of the string fields (ignoring RFC 4180, Section 2,\n Bullet 5).\n name: A name for the operation (optional).\n na_value: Additional string to recognize as NA/NaN.\n select_cols: Optional sorted list of column indices to select. If specified,\n only this subset of columns will be parsed and returned.\n\n Returns:\n A list of `Tensor` objects. Has the same type as `record_defaults`.\n Each tensor will have the same shape as records.\n\n Raises:\n ValueError: If any of the arguments is malformed.\n ", "desc": "Convert CSV records to tensors. Each column maps to one tensor.", "type": "API"}, {"name": "tf.compat.v1.decode_json_example", "docs": "Convert JSON-encoded Example records to binary protocol buffer strings.\n\n Note: This is **not** a general purpose JSON parsing op.\n\n This op converts JSON-serialized `tf.train.Example` (maybe created with\n `json_format.MessageToJson`, following the\n [standard JSON mapping](\n https://developers.google.com/protocol-buffers/docs/proto3#json))\n to a binary-serialized `tf.train.Example` (equivalent to\n `Example.SerializeToString()`) suitable for conversion to tensors with\n `tf.io.parse_example`.\n\n Here is a `tf.train.Example` proto:\n\n >>> example = tf.train.Example(\n ... features=tf.train.Features(\n ... feature={\n ... \"a\": tf.train.Feature(\n ... int64_list=tf.train.Int64List(\n ... value=[1, 1, 3]))}))\n\n Here it is converted to JSON:\n\n >>> from google.protobuf import json_format\n >>> example_json = json_format.MessageToJson(example)\n >>> print(example_json)\n {\n \"features\": {\n \"feature\": {\n \"a\": {\n \"int64List\": {\n \"value\": [\n \"1\",\n \"1\",\n \"3\"\n ]\n }\n }\n }\n }\n }\n\n This op converts the above json string to a binary proto:\n\n >>> example_binary = tf.io.decode_json_example(example_json)\n >>> example_binary.numpy()\n b'\\n\\x0f\\n\\r\\n\\x01a\\x12\\x08\\x1a\\x06\\x08\\x01\\x08\\x01\\x08\\x03'\n\n The OP works on string tensors of andy shape:\n\n >>> tf.io.decode_json_example([\n ... [example_json, example_json],\n ... [example_json, example_json]]).shape.as_list()\n [2, 2]\n\n This resulting binary-string is equivalent to `Example.SerializeToString()`,\n and can be converted to Tensors using `tf.io.parse_example` and related\n functions:\n\n >>> tf.io.parse_example(\n ... serialized=[example_binary.numpy(),\n ... example.SerializeToString()],\n ... features = {'a': tf.io.FixedLenFeature(shape=[3], dtype=tf.int64)})\n {'a': }\n\n Args:\n json_examples: A string tensor containing json-serialized `tf.Example`\n protos.\n name: A name for the op.\n\n Returns:\n A string Tensor containing the binary-serialized `tf.Example` protos.\n\n Raises:\n `tf.errors.InvalidArgumentError`: If the JSON could not be converted to a\n `tf.Example`\n ", "desc": "Convert JSON-encoded Example records to binary protocol buffer strings.", "type": "API"}, {"name": "tf.compat.v1.decode_raw", "docs": "Convert raw byte strings into tensors. (deprecated arguments)\n\nDeprecated: SOME ARGUMENTS ARE DEPRECATED: `(bytes)`. They will be removed in a future version.\nInstructions for updating:\nbytes is deprecated, use input_bytes instead\n\nArgs:\n input_bytes:\n Each element of the input Tensor is converted to an array of bytes.\n out_type:\n `DType` of the output. Acceptable types are `half`, `float`, `double`,\n `int32`, `uint16`, `uint8`, `int16`, `int8`, `int64`.\n little_endian:\n Whether the `input_bytes` data is in little-endian format. Data will be\n converted into host byte order if necessary.\n name: A name for the operation (optional).\n bytes: Deprecated parameter. Use `input_bytes` instead.\n\nReturns:\n A `Tensor` object storing the decoded bytes.", "desc": "Convert raw byte strings into tensors. (deprecated arguments)", "type": "API"}, {"name": "tf.compat.v1.delete_session_tensor", "docs": "Delete the tensor for the given tensor handle.\n\n This is EXPERIMENTAL and subject to change.\n\n Delete the tensor of a given tensor handle. The tensor is produced\n in a previous run() and stored in the state of the session.\n\n Args:\n handle: The string representation of a persistent tensor handle.\n name: Optional name prefix for the return tensor.\n\n Returns:\n A pair of graph elements. The first is a placeholder for feeding a\n tensor handle and the second is a deletion operation.\n ", "desc": "Delete the tensor for the given tensor handle.", "type": "API"}, {"name": "tf.compat.v1.depth_to_space", "docs": "DepthToSpace for tensors of type T.\n\n Rearranges data from depth into blocks of spatial data.\n This is the reverse transformation of SpaceToDepth. More specifically,\n this op outputs a copy of the input tensor where values from the `depth`\n dimension are moved in spatial blocks to the `height` and `width` dimensions.\n The attr `block_size` indicates the input block size and how the data is moved.\n\n * Chunks of data of size `block_size * block_size` from depth are rearranged\n into non-overlapping blocks of size `block_size x block_size`\n * The width the output tensor is `input_depth * block_size`, whereas the\n height is `input_height * block_size`.\n * The Y, X coordinates within each block of the output image are determined\n by the high order component of the input channel index.\n * The depth of the input tensor must be divisible by\n `block_size * block_size`.\n\n The `data_format` attr specifies the layout of the input and output tensors\n with the following options:\n \"NHWC\": `[ batch, height, width, channels ]`\n \"NCHW\": `[ batch, channels, height, width ]`\n \"NCHW_VECT_C\":\n `qint8 [ batch, channels / 4, height, width, 4 ]`\n\n It is useful to consider the operation as transforming a 6-D Tensor.\n e.g. for data_format = NHWC,\n Each element in the input tensor can be specified via 6 coordinates,\n ordered by decreasing memory layout significance as:\n n,iY,iX,bY,bX,oC (where n=batch index, iX, iY means X or Y coordinates\n within the input image, bX, bY means coordinates\n within the output block, oC means output channels).\n The output would be the input transposed to the following layout:\n n,iY,bY,iX,bX,oC\n\n This operation is useful for resizing the activations between convolutions\n (but keeping all data), e.g. instead of pooling. It is also useful for training\n purely convolutional models.\n\n For example, given an input of shape `[1, 1, 1, 4]`, data_format = \"NHWC\" and\n block_size = 2:\n\n ```\n x = [[[[1, 2, 3, 4]]]]\n\n ```\n\n This operation will output a tensor of shape `[1, 2, 2, 1]`:\n\n ```\n [[[[1], [2]],\n [[3], [4]]]]\n ```\n\n Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,\n the corresponding output will have 2x2 elements and will have a depth of\n 1 channel (1 = `4 / (block_size * block_size)`).\n The output element shape is `[2, 2, 1]`.\n\n For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.\n\n ```\n x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]\n ```\n\n This operation, for block size of 2, will return the following tensor of shape\n `[1, 2, 2, 3]`\n\n ```\n [[[[1, 2, 3], [4, 5, 6]],\n [[7, 8, 9], [10, 11, 12]]]]\n\n ```\n\n Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:\n\n ```\n x = [[[[1, 2, 3, 4],\n [5, 6, 7, 8]],\n [[9, 10, 11, 12],\n [13, 14, 15, 16]]]]\n ```\n\n the operator will return the following tensor of shape `[1 4 4 1]`:\n\n ```\n x = [[[ [1], [2], [5], [6]],\n [ [3], [4], [7], [8]],\n [ [9], [10], [13], [14]],\n [ [11], [12], [15], [16]]]]\n\n ```\n\n Args:\n input: A `Tensor`.\n block_size: An `int` that is `>= 2`.\n The size of the spatial block, same as in Space2Depth.\n data_format: An optional `string` from: `\"NHWC\", \"NCHW\", \"NCHW_VECT_C\"`. Defaults to `\"NHWC\"`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `input`.\n ", "desc": "DepthToSpace for tensors of type T.", "type": "API"}, {"name": "tf.compat.v1.dequantize", "docs": "Dequantize the 'input' tensor into a float or bfloat16 Tensor.\n\n [min_range, max_range] are scalar floats that specify the range for\n the output. The 'mode' attribute controls exactly which calculations are\n used to convert the float values to their quantized equivalents.\n\n In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:\n\n ```\n if T == qint8: in[i] += (range(T) + 1)/ 2.0\n out[i] = min_range + (in[i]* (max_range - min_range) / range(T))\n ```\n here `range(T) = numeric_limits::max() - numeric_limits::min()`\n\n *MIN_COMBINED Mode Example*\n\n If the input comes from a QuantizedRelu6, the output type is\n quint8 (range of 0-255) but the possible range of QuantizedRelu6 is\n 0-6. The min_range and max_range values are therefore 0.0 and 6.0.\n Dequantize on quint8 will take each value, cast to float, and multiply\n by 6 / 255.\n Note that if quantizedtype is qint8, the operation will additionally add\n each value by 128 prior to casting.\n\n If the mode is 'MIN_FIRST', then this approach is used:\n\n ```c++\n num_discrete_values = 1 << (# of bits in T)\n range_adjust = num_discrete_values / (num_discrete_values - 1)\n range = (range_max - range_min) * range_adjust\n range_scale = range / num_discrete_values\n const double offset_input = static_cast(input) - lowest_quantized;\n result = range_min + ((input - numeric_limits::min()) * range_scale)\n ```\n\n If the mode is `SCALED`, dequantization is performed by multiplying each\n input value by a scaling_factor. (Thus an input of 0 always maps to 0.0).\n\n The scaling_factor is determined from `min_range`, `max_range`, and\n `narrow_range` in a way that is compatible with `QuantizeAndDequantize{V2|V3}`\n and `QuantizeV2`, using the following algorithm:\n\n ```c++\n\n const int min_expected_T = std::numeric_limits::min() +\n (narrow_range ? 1 : 0);\n const int max_expected_T = std::numeric_limits::max();\n const float max_expected_T = std::numeric_limits::max();\n\n const float scale_factor =\n (std::numeric_limits::min() == 0) ? (max_range / max_expected_T)\n : std::max(min_range / min_expected_T,\n max_range / max_expected_T);\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `qint8`, `quint8`, `qint32`, `qint16`, `quint16`.\n min_range: A `Tensor` of type `float32`.\n The minimum scalar value possibly produced for the input.\n max_range: A `Tensor` of type `float32`.\n The maximum scalar value possibly produced for the input.\n mode: An optional `string` from: `\"MIN_COMBINED\", \"MIN_FIRST\", \"SCALED\"`. Defaults to `\"MIN_COMBINED\"`.\n narrow_range: An optional `bool`. Defaults to `False`.\n axis: An optional `int`. Defaults to `-1`.\n dtype: An optional `tf.DType` from: `tf.bfloat16, tf.float32`. Defaults to `tf.float32`.\n Type of the output tensor. Currently Dequantize supports float and bfloat16.\n If 'dtype' is 'bfloat16', it only supports 'MIN_COMBINED' mode.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `dtype`.\n ", "desc": "Dequantize the 'input' tensor into a float or bfloat16 Tensor.", "type": "API"}, {"name": "tf.compat.v1.deserialize_many_sparse", "docs": "Deserialize and concatenate `SparseTensors` from a serialized minibatch.\n\n The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where\n `N` is the minibatch size and the rows correspond to packed outputs of\n `serialize_sparse`. The ranks of the original `SparseTensor` objects\n must all match. When the final `SparseTensor` is created, it has rank one\n higher than the ranks of the incoming `SparseTensor` objects (they have been\n concatenated along a new row dimension).\n\n The output `SparseTensor` object's shape values for all dimensions but the\n first are the max across the input `SparseTensor` objects' shape values\n for the corresponding dimensions. Its first shape value is `N`, the minibatch\n size.\n\n The input `SparseTensor` objects' indices are assumed ordered in\n standard lexicographic order. If this is not the case, after this\n step run `sparse.reorder` to restore index ordering.\n\n For example, if the serialized input is a `[2, 3]` matrix representing two\n original `SparseTensor` objects:\n\n index = [ 0]\n [10]\n [20]\n values = [1, 2, 3]\n shape = [50]\n\n and\n\n index = [ 2]\n [10]\n values = [4, 5]\n shape = [30]\n\n then the final deserialized `SparseTensor` will be:\n\n index = [0 0]\n [0 10]\n [0 20]\n [1 2]\n [1 10]\n values = [1, 2, 3, 4, 5]\n shape = [2 50]\n\n Args:\n serialized_sparse: 2-D `Tensor` of type `string` of shape `[N, 3]`.\n The serialized and packed `SparseTensor` objects.\n dtype: The `dtype` of the serialized `SparseTensor` objects.\n rank: (optional) Python int, the rank of the `SparseTensor` objects.\n name: A name prefix for the returned tensors (optional)\n\n Returns:\n A `SparseTensor` representing the deserialized `SparseTensor`s,\n concatenated along the `SparseTensor`s' first dimension.\n\n All of the serialized `SparseTensor`s must have had the same rank and type.\n ", "desc": "Deserialize and concatenate `SparseTensors` from a serialized minibatch.", "type": "API"}, {"name": "tf.compat.v1.device", "docs": "Wrapper for `Graph.device()` using the default graph.\n\n See `tf.Graph.device` for more details.\n\n Args:\n device_name_or_function: The device name or function to use in the context.\n\n Returns:\n A context manager that specifies the default device to use for newly\n created ops.\n\n Raises:\n RuntimeError: If eager execution is enabled and a function is passed in.\n ", "desc": "Wrapper for `Graph.device()` using the default graph.", "type": "API"}, {"name": "tf.compat.v1.DeviceSpec", "docs": "Represents a (possibly partial) specification for a TensorFlow device.\n\n `DeviceSpec`s are used throughout TensorFlow to describe where state is stored\n and computations occur. Using `DeviceSpec` allows you to parse device spec\n strings to verify their validity, merge them or compose them programmatically.\n\n Example:\n\n ```python\n # Place the operations on device \"GPU:0\" in the \"ps\" job.\n device_spec = DeviceSpec(job=\"ps\", device_type=\"GPU\", device_index=0)\n with tf.device(device_spec.to_string()):\n # Both my_var and squared_var will be placed on /job:ps/device:GPU:0.\n my_var = tf.Variable(..., name=\"my_variable\")\n squared_var = tf.square(my_var)\n ```\n\n With eager execution disabled (by default in TensorFlow 1.x and by calling\n disable_eager_execution() in TensorFlow 2.x), the following syntax\n can be used:\n\n ```python\n tf.compat.v1.disable_eager_execution()\n\n # Same as previous\n device_spec = DeviceSpec(job=\"ps\", device_type=\"GPU\", device_index=0)\n # No need of .to_string() method.\n with tf.device(device_spec):\n my_var = tf.Variable(..., name=\"my_variable\")\n squared_var = tf.square(my_var)\n ```\n\n If a `DeviceSpec` is partially specified, it will be merged with other\n `DeviceSpec`s according to the scope in which it is defined. `DeviceSpec`\n components defined in inner scopes take precedence over those defined in\n outer scopes.\n\n ```python\n gpu0_spec = DeviceSpec(job=\"ps\", device_type=\"GPU\", device_index=0)\n with tf.device(DeviceSpec(job=\"train\").to_string()):\n with tf.device(gpu0_spec.to_string()):\n # Nodes created here will be assigned to /job:ps/device:GPU:0.\n with tf.device(DeviceSpec(device_type=\"GPU\", device_index=1).to_string()):\n # Nodes created here will be assigned to /job:train/device:GPU:1.\n ```\n\n A `DeviceSpec` consists of 5 components -- each of\n which is optionally specified:\n\n * Job: The job name.\n * Replica: The replica index.\n * Task: The task index.\n * Device type: The device type string (e.g. \"CPU\" or \"GPU\").\n * Device index: The device index.\n ", "desc": "Represents a (possibly partial) specification for a TensorFlow device.", "type": "API"}, {"name": "tf.compat.v1.diag", "docs": "Returns a diagonal tensor with a given diagonal values.\n\n Given a `diagonal`, this operation returns a tensor with the `diagonal` and\n everything else padded with zeros. The diagonal is computed as follows:\n\n Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of\n rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:\n\n `output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.\n\n For example:\n\n ```\n # 'diagonal' is [1, 2, 3, 4]\n tf.diag(diagonal) ==> [[1, 0, 0, 0]\n [0, 2, 0, 0]\n [0, 0, 3, 0]\n [0, 0, 0, 4]]\n ```\n\n Args:\n diagonal: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n Rank k tensor where k is at most 1.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `diagonal`.\n ", "desc": "Returns a diagonal tensor with a given diagonal values.", "type": "API"}, {"name": "tf.compat.v1.diag_part", "docs": "Returns the diagonal part of the tensor.\n\n This operation returns a tensor with the `diagonal` part\n of the `input`. The `diagonal` part is computed as follows:\n\n Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a\n tensor of rank `k` with dimensions `[D1,..., Dk]` where:\n\n `diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.\n\n For a rank 2 tensor, `linalg.diag_part` and `linalg.tensor_diag_part`\n produce the same result. For rank 3 and higher, linalg.diag_part extracts\n the diagonal of each inner-most matrix in the tensor. An example where\n they differ is given below.\n\n >>> x = [[[[1111,1112],[1121,1122]],\n ... [[1211,1212],[1221,1222]]],\n ... [[[2111, 2112], [2121, 2122]],\n ... [[2211, 2212], [2221, 2222]]]\n ... ]\n >>> tf.linalg.tensor_diag_part(x)\n \n >>> tf.linalg.diag_part(x).shape\n TensorShape([2, 2, 2])\n\n Args:\n input: A `Tensor` with rank `2k`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor containing diagonals of `input`. Has the same type as `input`, and\n rank `k`.\n ", "desc": "Returns the diagonal part of the tensor.", "type": "API"}, {"name": "tf.compat.v1.digamma", "docs": "Computes Psi, the derivative of Lgamma (the log of the absolute value of\n\n `Gamma(x)`), element-wise.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n ", "desc": "Computes Psi, the derivative of Lgamma (the log of the absolute value of", "type": "API"}, {"name": "tf.compat.v1.Dimension", "docs": "Represents the value of one dimension in a TensorShape.\n\n @compatibility(TF2)\n In TF2, members of a `TensorShape` object are integers. The `Dimension` class\n is not part of TF2's data model.\n\n Please refer to the [TensorShape section of the migration guide]\n (https://www.tensorflow.org/guide/migrate/index#tensorshape) on common code\n patterns adapting Dimension objects to a TF2 syntax.\n @end_compatibility\n ", "desc": "Represents the value of one dimension in a TensorShape.", "type": "API"}, {"name": "tf.compat.v1.dimension_at_index", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n If you want to retrieve the Dimension instance corresponding to a certain\n index in a TensorShape instance, use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n dim = tensor_shape[i]\n\n # Use `dimension_at_index` as direct replacement compatible with both V1 & V2:\n dim = dimension_at_index(tensor_shape, i)\n\n # Another possibility would be this, but WARNING: it only works if the\n # tensor_shape instance has a defined rank.\n dim = tensor_shape.dims[i] # `dims` may be None if the rank is undefined!\n\n # In native V2 code, we recommend instead being more explicit:\n if tensor_shape.rank is None:\n dim = Dimension(None)\n else:\n dim = tensor_shape.dims[i]\n\n # Being more explicit will save you from the following trap (present in V1):\n # you might do in-place modifications to `dim` and expect them to be reflected\n # in `tensor_shape[i]`, but they would not be (as the Dimension object was\n # instantiated on the fly.\n ```\n\n Args:\n shape: A TensorShape instance.\n index: An integer index.\n\n Returns:\n A dimension object.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.v1.dimension_value", "docs": "Compatibility utility required to allow for both V1 and V2 behavior in TF.\n\n Until the release of TF 2.0, we need the legacy behavior of `TensorShape` to\n coexist with the new behavior. This utility is a bridge between the two.\n\n When accessing the value of a TensorShape dimension,\n use this utility, like this:\n\n ```\n # If you had this in your V1 code:\n value = tensor_shape[i].value\n\n # Use `dimension_value` as direct replacement compatible with both V1 & V2:\n value = dimension_value(tensor_shape[i])\n\n # This would be the V2 equivalent:\n value = tensor_shape[i] # Warning: this will return the dim value in V2!\n ```\n\n Args:\n dimension: Either a `Dimension` instance, an integer, or None.\n\n Returns:\n A plain value, i.e. an integer or None.\n ", "desc": "Compatibility utility required to allow for both V1 and V2 behavior in TF.", "type": "API"}, {"name": "tf.compat.v1.disable_control_flow_v2", "docs": "Opts out of control flow v2.\n\n Note: v2 control flow is always enabled inside of tf.function. Calling this\n function has no effect in that case.\n\n If your code needs tf.disable_control_flow_v2() to be called to work\n properly please file a bug.\n ", "desc": "Opts out of control flow v2.", "type": "API"}, {"name": "tf.compat.v1.disable_eager_execution", "docs": "Disables eager execution.\n\n This function can only be called before any Graphs, Ops, or Tensors have been\n created.\n\n @compatibility(TF2)\n This function is not necessary if you are using TF2. Eager execution is\n enabled by default. If you want to use Graph mode please consider\n [tf.function](https://www.tensorflow.org/api_docs/python/tf/function).\n @end_compatibility\n ", "desc": "Disables eager execution.", "type": "API"}, {"name": "tf.compat.v1.disable_resource_variables", "docs": "Opts out of resource variables. (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nnon-resource variables are not supported in the long term\n\nIf your code needs tf.disable_resource_variables() to be called to work\nproperly please file a bug.", "desc": "Opts out of resource variables. (deprecated)", "type": "API"}, {"name": "tf.compat.v1.disable_tensor_equality", "docs": "Compare Tensors by their id and be hashable.\n\n This is a legacy behaviour of TensorFlow and is highly discouraged.\n ", "desc": "Compare Tensors by their id and be hashable.", "type": "API"}, {"name": "tf.compat.v1.disable_v2_behavior", "docs": "Disables TensorFlow 2.x behaviors.\n\n This function can be called at the beginning of the program (before `Tensors`,\n `Graphs` or other structures have been created, and before devices have been\n initialized. It switches all global behaviors that are different between\n TensorFlow 1.x and 2.x to behave as intended for 1.x.\n\n User can call this function to disable 2.x behavior during complex migrations.\n\n @compatibility(TF2)\n Using this function indicates that your software is not compatible\n with eager execution and `tf.function` in TF2.\n\n To migrate to TF2, rewrite your code to be compatible with eager execution.\n Please refer to the [migration guide]\n (https://www.tensorflow.org/guide/migrate) for additional resource on the\n topic.\n @end_compatibility\n ", "desc": "Disables TensorFlow 2.x behaviors.", "type": "API"}, {"name": "tf.compat.v1.disable_v2_tensorshape", "docs": "Disables the V2 TensorShape behavior and reverts to V1 behavior.\n\n See docstring for `enable_v2_tensorshape` for details about the new behavior.\n ", "desc": "Disables the V2 TensorShape behavior and reverts to V1 behavior.", "type": "API"}, {"name": "tf.compat.v1.distribute", "docs": "Library for running a computation across multiple devices.\n\nThe intent of this library is that you can write an algorithm in a stylized way\nand it will be usable with a variety of different `tf.distribute.Strategy`\nimplementations. Each descendant will implement a different strategy for\ndistributing the algorithm across multiple devices/machines. Furthermore, these\nchanges can be hidden inside the specific layers and other library classes that\nneed special treatment to run in a distributed setting, so that most users'\nmodel definition code can run unchanged. The `tf.distribute.Strategy` API works\nthe same way with eager and graph execution.\n\n*Guides*\n\n* [TensorFlow v2.x](https://www.tensorflow.org/guide/distributed_training)\n* [TensorFlow v1.x](https://github.com/tensorflow/docs/blob/master/site/en/r1/guide/distribute_strategy.ipynb)\n\n*Tutorials*\n\n* [Distributed Training Tutorials](https://www.tensorflow.org/tutorials/distribute/)\n\n The tutorials cover how to use `tf.distribute.Strategy` to do distributed\n training with native Keras APIs, custom training loops,\n and Estimator APIs. They also cover how to save/load model when using\n `tf.distribute.Strategy`.\n\n*Glossary*\n\n* _Data parallelism_ is where we run multiple copies of the model\n on different slices of the input data. This is in contrast to\n _model parallelism_ where we divide up a single copy of a model\n across multiple devices.\n Note: we only support data parallelism for now, but\n hope to add support for model parallelism in the future.\n* A _device_ is a CPU or accelerator (e.g. GPUs, TPUs) on some machine that\n TensorFlow can run operations on (see e.g. `tf.device`). You may have multiple\n devices on a single machine, or be connected to devices on multiple\n machines. Devices used to run computations are called _worker devices_.\n Devices used to store variables are _parameter devices_. For some strategies,\n such as `tf.distribute.MirroredStrategy`, the worker and parameter devices\n will be the same (see mirrored variables below). For others they will be\n different. For example, `tf.distribute.experimental.CentralStorageStrategy`\n puts the variables on a single device (which may be a worker device or may be\n the CPU), and `tf.distribute.experimental.ParameterServerStrategy` puts the\n variables on separate machines called _parameter servers_ (see below).\n* A _replica_ is one copy of the model, running on one slice of the\n input data. Right now each replica is executed on its own\n worker device, but once we add support for model parallelism\n a replica may span multiple worker devices.\n* A _host_ is the CPU device on a machine with worker devices, typically\n used for running input pipelines.\n* A _worker_ is defined to be the physical machine(s) containing the physical\n devices (e.g. GPUs, TPUs) on which the replicated computation is executed. A\n worker may contain one or more replicas, but contains at least one\n replica. Typically one worker will correspond to one machine, but in the case\n of very large models with model parallelism, one worker may span multiple\n machines. We typically run one input pipeline per worker, feeding all the\n replicas on that worker.\n* _Synchronous_, or more commonly _sync_, training is where the updates from\n each replica are aggregated together before updating the model variables. This\n is in contrast to _asynchronous_, or _async_ training, where each replica\n updates the model variables independently. You may also have replicas\n partitioned into groups which are in sync within each group but async between\n groups.\n* _Parameter servers_: These are machines that hold a single copy of\n parameters/variables, used by some strategies (right now just\n `tf.distribute.experimental.ParameterServerStrategy`). All replicas that want\n to operate on a variable retrieve it at the beginning of a step and send an\n update to be applied at the end of the step. These can in principle support\n either sync or async training, but right now we only have support for async\n training with parameter servers. Compare to\n `tf.distribute.experimental.CentralStorageStrategy`, which puts all variables\n on a single device on the same machine (and does sync training), and\n `tf.distribute.MirroredStrategy`, which mirrors variables to multiple devices\n (see below).\n\n* _Replica context_ vs. _Cross-replica context_ vs _Update context_\n\n A _replica context_ applies\n when you execute the computation function that was called with `strategy.run`.\n Conceptually, you're in replica context when executing the computation\n function that is being replicated.\n\n An _update context_ is entered in a `tf.distribute.StrategyExtended.update`\n call.\n\n An _cross-replica context_ is entered when you enter a `strategy.scope`. This\n is useful for calling `tf.distribute.Strategy` methods which operate across\n the replicas (like `reduce_to()`). By default you start in a _replica context_\n (the \"default single _replica context_\") and then some methods can switch you\n back and forth.\n\n* _Distributed value_: Distributed value is represented by the base class\n `tf.distribute.DistributedValues`. `tf.distribute.DistributedValues` is useful\n to represent values on multiple devices, and it contains a map from replica id\n to values. Two representative kinds of `tf.distribute.DistributedValues` are\n \"PerReplica\" and \"Mirrored\" values.\n\n \"PerReplica\" values exist on the worker\n devices, with a different value for each replica. They are produced by\n iterating through a distributed dataset returned by\n `tf.distribute.Strategy.experimental_distribute_dataset` and\n `tf.distribute.Strategy.distribute_datasets_from_function`. They\n are also the typical result returned by\n `tf.distribute.Strategy.run`.\n\n \"Mirrored\" values are like \"PerReplica\" values, except we know that the value\n on all replicas are the same. We can safely read a \"Mirrored\" value in a\n cross-replica context by using the value on any replica.\n\n* _Unwrapping_ and _merging_: Consider calling a function `fn` on multiple\n replicas, like `strategy.run(fn, args=[w])` with an\n argument `w` that is a `tf.distribute.DistributedValues`. This means `w` will\n have a map taking replica id `0` to `w0`, replica id `1` to `w1`, etc.\n `strategy.run()` unwraps `w` before calling `fn`, so it calls `fn(w0)` on\n device `d0`, `fn(w1)` on device `d1`, etc. It then merges the return\n values from `fn()`, which leads to one common object if the returned values\n are the same object from every replica, or a `DistributedValues` object\n otherwise.\n\n* _Reductions_ and _all-reduce_: A _reduction_ is a method of aggregating\n multiple values into one value, like \"sum\" or \"mean\". If a strategy is doing\n sync training, we will perform a reduction on the gradients to a parameter\n from all replicas before applying the update. _All-reduce_ is an algorithm for\n performing a reduction on values from multiple devices and making the result\n available on all of those devices.\n\n* _Mirrored variables_: These are variables that are created on multiple\n devices, where we keep the variables in sync by applying the same\n updates to every copy. Mirrored variables are created with\n `tf.Variable(...synchronization=tf.VariableSynchronization.ON_WRITE...)`.\n Normally they are only used in synchronous training.\n\n* _SyncOnRead variables_\n\n _SyncOnRead variables_ are created by\n `tf.Variable(...synchronization=tf.VariableSynchronization.ON_READ...)`, and\n they are created on multiple devices. In replica context, each\n component variable on the local replica can perform reads and writes without\n synchronization with each other. When the\n _SyncOnRead variable_ is read in cross-replica context, the values from\n component variables are aggregated and returned.\n\n _SyncOnRead variables_ bring a lot of custom configuration difficulty to the\n underlying logic, so we do not encourage users to instantiate and use\n _SyncOnRead variable_ on their own. We have mainly used _SyncOnRead\n variables_ for use cases such as batch norm and metrics. For performance\n reasons, we often don't need to keep these statistics in sync every step and\n they can be accumulated on each replica independently. The only time we want\n to sync them is reporting or checkpointing, which typically happens in\n cross-replica context. _SyncOnRead variables_ are also often used by advanced\n users who want to control when variable values are aggregated. For example,\n users sometimes want to maintain gradients independently on each replica for a\n couple of steps without aggregation.\n\n* _Distribute-aware layers_\n\n Layers are generally called in a replica context, except when defining a\n Keras functional model. `tf.distribute.in_cross_replica_context` will let you\n determine which case you are in. If in a replica context,\n the `tf.distribute.get_replica_context` function will return the default\n replica context outside a strategy scope, `None` within a strategy scope, and\n a `tf.distribute.ReplicaContext` object inside a strategy scope and within a\n `tf.distribute.Strategy.run` function. The `ReplicaContext` object has an\n `all_reduce` method for aggregating across all replicas.\n\n\nNote that we provide a default version of `tf.distribute.Strategy` that is\nused when no other strategy is in scope, that provides the same API with\nreasonable default behavior.\n\n", "desc": "Library for running a computation across multiple devices.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver", "docs": "Library imports for ClusterResolvers.\n\n This library contains all implementations of ClusterResolvers.\n ClusterResolvers are a way of specifying cluster information for distributed\n execution. Built on top of existing `ClusterSpec` framework, ClusterResolvers\n are a way for TensorFlow to communicate with various cluster management\n systems (e.g. GCE, AWS, etc...).\n\n", "desc": "Library imports for ClusterResolvers.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.ClusterResolver", "docs": "Abstract class for all implementations of ClusterResolvers.\n\n This defines the skeleton for all implementations of ClusterResolvers.\n ClusterResolvers are a way for TensorFlow to communicate with various cluster\n management systems (e.g. GCE, AWS, etc...) and gives TensorFlow necessary\n information to set up distributed training.\n\n By letting TensorFlow communicate with these systems, we will be able to\n automatically discover and resolve IP addresses for various TensorFlow\n workers. This will eventually allow us to automatically recover from\n underlying machine failures and scale TensorFlow worker clusters up and down.\n\n Note to Implementors of `tf.distribute.cluster_resolver.ClusterResolver`\n subclass: In addition to these abstract methods, when task_type, task_id, and\n rpc_layer attributes are applicable, you should also implement them either as\n properties with getters or setters, or directly set the attributes\n `self._task_type`, `self._task_id`, or `self._rpc_layer` so the base class'\n getters and setters are used. See\n `tf.distribute.cluster_resolver.SimpleClusterResolver.__init__` for an\n example.\n\n In general, multi-client tf.distribute strategies such as\n `tf.distribute.experimental.MultiWorkerMirroredStrategy` require task_type and\n task_id properties to be available in the `ClusterResolver` they are using. On\n the other hand, these concepts are not applicable in single-client strategies,\n such as `tf.distribute.experimental.TPUStrategy`, because the program is only\n expected to be run on one task, so there should not be a need to have code\n branches according to task type and task id.\n\n - task_type is the name of the server's current named job (e.g. 'worker',\n 'ps' in a distributed parameterized training job).\n - task_id is the ordinal index of the server within the task type.\n - rpc_layer is the protocol used by TensorFlow to communicate with other\n TensorFlow servers in a distributed environment.\n ", "desc": "Abstract class for all implementations of ClusterResolvers.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.GCEClusterResolver", "docs": "ClusterResolver for Google Compute Engine.\n\n This is an implementation of cluster resolvers for the Google Compute Engine\n instance group platform. By specifying a project, zone, and instance group,\n this will retrieve the IP address of all the instances within the instance\n group and return a ClusterResolver object suitable for use for distributed\n TensorFlow.\n\n Note: this cluster resolver cannot retrieve `task_type`, `task_id` or\n `rpc_layer`. To use it with some distribution strategies like\n `tf.distribute.experimental.MultiWorkerMirroredStrategy`, you will need to\n specify `task_type` and `task_id` in the constructor.\n\n Usage example with tf.distribute.Strategy:\n\n ```Python\n # On worker 0\n cluster_resolver = GCEClusterResolver(\"my-project\", \"us-west1\",\n \"my-instance-group\",\n task_type=\"worker\", task_id=0)\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n\n # On worker 1\n cluster_resolver = GCEClusterResolver(\"my-project\", \"us-west1\",\n \"my-instance-group\",\n task_type=\"worker\", task_id=1)\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n ```\n ", "desc": "ClusterResolver for Google Compute Engine.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.KubernetesClusterResolver", "docs": "ClusterResolver for Kubernetes.\n\n This is an implementation of cluster resolvers for Kubernetes. When given the\n the Kubernetes namespace and label selector for pods, we will retrieve the\n pod IP addresses of all running pods matching the selector, and return a\n ClusterSpec based on that information.\n\n Note: it cannot retrieve `task_type`, `task_id` or `rpc_layer`. To use it\n with some distribution strategies like\n `tf.distribute.experimental.MultiWorkerMirroredStrategy`, you will need to\n specify `task_type` and `task_id` by setting these attributes.\n\n Usage example with tf.distribute.Strategy:\n\n ```Python\n # On worker 0\n cluster_resolver = KubernetesClusterResolver(\n {\"worker\": [\"job-name=worker-cluster-a\", \"job-name=worker-cluster-b\"]})\n cluster_resolver.task_type = \"worker\"\n cluster_resolver.task_id = 0\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n\n # On worker 1\n cluster_resolver = KubernetesClusterResolver(\n {\"worker\": [\"job-name=worker-cluster-a\", \"job-name=worker-cluster-b\"]})\n cluster_resolver.task_type = \"worker\"\n cluster_resolver.task_id = 1\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n ```\n ", "desc": "ClusterResolver for Kubernetes.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.SimpleClusterResolver", "docs": "Simple implementation of ClusterResolver that accepts all attributes.\n\n Please see the base class for documentation of arguments of its constructor.\n\n It is useful if you want to specify some or all attributes.\n\n Usage example with `tf.distribute.Strategy`:\n\n ```Python\n cluster = tf.train.ClusterSpec({\"worker\": [\"worker0.example.com:2222\",\n \"worker1.example.com:2222\"]})\n\n # On worker 0\n cluster_resolver = SimpleClusterResolver(cluster, task_type=\"worker\",\n task_id=0,\n num_accelerators={\"GPU\": 8},\n rpc_layer=\"grpc\")\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n\n # On worker 1\n cluster_resolver = SimpleClusterResolver(cluster, task_type=\"worker\",\n task_id=1,\n num_accelerators={\"GPU\": 8},\n rpc_layer=\"grpc\")\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=cluster_resolver)\n ```\n ", "desc": "Simple implementation of ClusterResolver that accepts all attributes.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.SlurmClusterResolver", "docs": "ClusterResolver for system with Slurm workload manager.\n\n This is an implementation of ClusterResolver for Slurm clusters. This allows\n the specification of jobs and task counts, number of tasks per node, number\n of GPUs on each node and number of GPUs for each task. It retrieves system\n attributes by Slurm environment variables, resolves allocated computing node\n names, constructs a cluster and returns a ClusterResolver object which can be\n used for distributed TensorFlow.\n ", "desc": "ClusterResolver for system with Slurm workload manager.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.TFConfigClusterResolver", "docs": "Implementation of a ClusterResolver which reads the TF_CONFIG EnvVar.\n\n This is an implementation of cluster resolvers when using TF_CONFIG to set\n information about the cluster. The cluster spec returned will be\n initialized from the TF_CONFIG environment variable.\n\n An example to set TF_CONFIG is:\n\n ```Python\n os.environ['TF_CONFIG'] = json.dumps({\n 'cluster': {\n 'worker': [\"localhost:12345\", \"localhost:23456\"]\n },\n 'task': {'type': 'worker', 'index': 0}\n })\n ```\n\n However, sometimes the container orchestration framework will set TF_CONFIG\n for you. In this case, you can just create an instance without passing in any\n arguments. You can find an example here to let Kuburnetes set TF_CONFIG for\n you: https://github.com/tensorflow/ecosystem/tree/master/kubernetes. Then you\n can use it with `tf.distribute.Strategy` as:\n\n ```Python\n # `TFConfigClusterResolver` is already the default one in the following\n # strategy.\n strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(\n cluster_resolver=TFConfigClusterResolver())\n ```\n ", "desc": "Implementation of a ClusterResolver which reads the TF_CONFIG EnvVar.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.TPUClusterResolver", "docs": "Cluster Resolver for Google Cloud TPUs.\n\n This is an implementation of cluster resolvers for the Google Cloud TPU\n service.\n\n TPUClusterResolver supports the following distinct environments:\n Google Compute Engine\n Google Kubernetes Engine\n Google internal\n\n It can be passed into `tf.distribute.TPUStrategy` to support TF2 training on\n Cloud TPUs.\n ", "desc": "Cluster Resolver for Google Cloud TPUs.", "type": "API"}, {"name": "tf.compat.v1.distribute.cluster_resolver.UnionResolver", "docs": "Performs a union on underlying ClusterResolvers.\n\n This class performs a union given two or more existing ClusterResolvers. It\n merges the underlying ClusterResolvers, and returns one unified ClusterSpec\n when cluster_spec is called. The details of the merge function is\n documented in the cluster_spec function.\n\n For additional ClusterResolver properties such as task type, task index,\n rpc layer, environment, etc..., we will return the value from the first\n ClusterResolver in the union.\n\n An example to combine two cluster resolvers:\n\n ```Python\n cluster_0 = tf.train.ClusterSpec({\"worker\": [\"worker0.example.com:2222\",\n \"worker1.example.com:2222\"]})\n cluster_resolver_0 = SimpleClusterResolver(cluster, task_type=\"worker\",\n task_id=0,\n rpc_layer=\"grpc\")\n\n cluster_1 = tf.train.ClusterSpec({\"ps\": [\"ps0.example.com:2222\",\n \"ps1.example.com:2222\"]})\n cluster_resolver_1 = SimpleClusterResolver(cluster, task_type=\"ps\",\n task_id=0,\n rpc_layer=\"grpc\")\n\n # Its task type would be \"worker\".\n cluster_resolver = UnionClusterResolver(cluster_resolver_0,\n cluster_resolver_1)\n ```\n\n An example to override the number of GPUs in a TFConfigClusterResolver\n instance:\n\n ```Python\n tf_config = TFConfigClusterResolver()\n gpu_override = SimpleClusterResolver(tf_config.cluster_spec(),\n num_accelerators={\"GPU\": 1})\n cluster_resolver = UnionResolver(gpu_override, tf_config)\n ```\n ", "desc": "Performs a union on underlying ClusterResolvers.", "type": "API"}, {"name": "tf.compat.v1.distribute.CrossDeviceOps", "docs": "Base class for cross-device reduction and broadcasting algorithms.\n\n The main purpose of this class is to be passed to\n `tf.distribute.MirroredStrategy` in order to choose among different cross\n device communication implementations. Prefer using the methods of\n `tf.distribute.Strategy` instead of the ones of this class.\n\n Implementations:\n * `tf.distribute.ReductionToOneDevice`\n * `tf.distribute.NcclAllReduce`\n * `tf.distribute.HierarchicalCopyAllReduce`\n ", "desc": "Base class for cross-device reduction and broadcasting algorithms.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental", "docs": "Experimental Distribution Strategy library.\n", "desc": "Experimental Distribution Strategy library.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.CentralStorageStrategy", "docs": "A one-machine strategy that puts all variables on a single device.\n\n Variables are assigned to local CPU or the only GPU. If there is more\n than one GPU, compute operations (other than variable update operations)\n will be replicated across all GPUs.\n\n For Example:\n ```\n strategy = tf.distribute.experimental.CentralStorageStrategy()\n # Create a dataset\n ds = tf.data.Dataset.range(5).batch(2)\n # Distribute that dataset\n dist_dataset = strategy.experimental_distribute_dataset(ds)\n\n with strategy.scope():\n @tf.function\n def train_step(val):\n return val + 1\n\n # Iterate over the distributed dataset\n for x in dist_dataset:\n # process dataset elements\n strategy.run(train_step, args=(x,))\n ```\n ", "desc": "A one-machine strategy that puts all variables on a single device.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.CollectiveCommunication", "docs": "Cross device communication implementation.\n\n Warning: The alias `tf.distribute.experimental.CollectiveCommunication` is\n deprecated and will be removed in a future version. Use\n `tf.distribute.experimental.CommunicationImplementation` instead.\n\n * `AUTO`: Automatically chosen by Tensorflow.\n * `RING`: TensorFlow's ring algorithms for all-reduce and\n all-gather.\n * `NCCL`: NVIDIA\u00ae's NCCL library. This is now only used for all-reduce on\n GPUs; all-reduce on CPU, all-gather and broadcast fallbacks to RING.\n ", "desc": "Cross device communication implementation.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.CollectiveHints", "docs": "Hints for collective operations like AllReduce.\n\n This can be passed to methods like\n `tf.distribute.get_replica_context().all_reduce()` to optimize collective\n operation performance. Note that these are only hints, which may or may not\n change the actual behavior. Some options only apply to certain strategy and\n are ignored by others.\n\n One common optimization is to break gradients all-reduce into multiple packs\n so that weight updates can overlap with gradient all-reduce.\n\n Examples:\n\n - bytes_per_pack\n\n ```python\n hints = tf.distribute.experimental.CollectiveHints(\n bytes_per_pack=50 * 1024 * 1024)\n grads = tf.distribute.get_replica_context().all_reduce(\n 'sum', grads, experimental_hints=hints)\n optimizer.apply_gradients(zip(grads, vars),\n experimental_aggregate_gradients=False)\n ```\n\n - timeout_seconds\n\n ```python\n strategy = tf.distribute.MirroredStrategy()\n hints = tf.distribute.experimental.CollectiveHints(\n timeout_seconds=120.0)\n try:\n strategy.reduce(\"sum\", v, axis=None, experimental_hints=hints)\n except tf.errors.DeadlineExceededError:\n do_something()\n ```\n\n ", "desc": "Hints for collective operations like AllReduce.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.CommunicationImplementation", "docs": "Cross device communication implementation.\n\n Warning: The alias `tf.distribute.experimental.CollectiveCommunication` is\n deprecated and will be removed in a future version. Use\n `tf.distribute.experimental.CommunicationImplementation` instead.\n\n * `AUTO`: Automatically chosen by Tensorflow.\n * `RING`: TensorFlow's ring algorithms for all-reduce and\n all-gather.\n * `NCCL`: NVIDIA\u00ae's NCCL library. This is now only used for all-reduce on\n GPUs; all-reduce on CPU, all-gather and broadcast fallbacks to RING.\n ", "desc": "Cross device communication implementation.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.CommunicationOptions", "docs": "Options for cross device communications like All-reduce.\n\n This can be passed to methods like\n `tf.distribute.get_replica_context().all_reduce()` to optimize collective\n operation performance. Note that these are only hints, which may or may not\n change the actual behavior. Some options only apply to certain strategy and\n are ignored by others.\n\n One common optimization is to break gradients all-reduce into multiple packs\n so that weight updates can overlap with gradient all-reduce.\n\n Examples:\n\n ```python\n options = tf.distribute.experimental.CommunicationOptions(\n bytes_per_pack=50 * 1024 * 1024,\n timeout_seconds=120.0,\n implementation=tf.distribute.experimental.CommunicationImplementation.NCCL\n )\n grads = tf.distribute.get_replica_context().all_reduce(\n 'sum', grads, options=options)\n optimizer.apply_gradients(zip(grads, vars),\n experimental_aggregate_gradients=False)\n ```\n\n ", "desc": "Options for cross device communications like All-reduce.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.MultiWorkerMirroredStrategy", "docs": "A distribution strategy for synchronous training on multiple workers.\n\n This strategy implements synchronous distributed training across multiple\n workers, each with potentially multiple GPUs. Similar to\n `tf.distribute.MirroredStrategy`, it replicates all variables and computations\n to each local device. The difference is that it uses a distributed collective\n implementation (e.g. all-reduce), so that multiple workers can work together.\n\n You need to launch your program on each worker and configure\n `cluster_resolver` correctly. For example, if you are using\n `tf.distribute.cluster_resolver.TFConfigClusterResolver`, each worker needs to\n have its corresponding `task_type` and `task_id` set in the `TF_CONFIG`\n environment variable. An example TF_CONFIG on worker-0 of a two worker cluster\n is:\n\n ```\n TF_CONFIG = '{\"cluster\": {\"worker\": [\"localhost:12345\", \"localhost:23456\"]}, \"task\": {\"type\": \"worker\", \"index\": 0} }'\n ```\n\n Your program runs on each worker as-is. Note that collectives require each\n worker to participate. All `tf.distribute` and non `tf.distribute` API may use\n collectives internally, e.g. checkpointing and saving since reading a\n `tf.Variable` with `tf.VariableSynchronization.ON_READ` all-reduces the value.\n Therefore it's recommended to run exactly the same program on each worker.\n Dispatching based on `task_type` or `task_id` of the worker is error-prone.\n\n `cluster_resolver.num_accelerators()` determines the number of GPUs the\n strategy uses. If it's zero, the strategy uses the CPU. All workers need to\n use the same number of devices, otherwise the behavior is undefined.\n\n This strategy is not intended for TPU. Use `tf.distribute.TPUStrategy`\n instead.\n\n After setting up TF_CONFIG, using this strategy is similar to using\n `tf.distribute.MirroredStrategy` and `tf.distribute.TPUStrategy`.\n\n ```\n strategy = tf.distribute.MultiWorkerMirroredStrategy()\n\n with strategy.scope():\n model = tf.keras.Sequential([\n tf.keras.layers.Dense(2, input_shape=(5,)),\n ])\n optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)\n\n def dataset_fn(ctx):\n x = np.random.random((2, 5)).astype(np.float32)\n y = np.random.randint(2, size=(2, 1))\n dataset = tf.data.Dataset.from_tensor_slices((x, y))\n return dataset.repeat().batch(1, drop_remainder=True)\n dist_dataset = strategy.distribute_datasets_from_function(dataset_fn)\n\n model.compile()\n model.fit(dist_dataset)\n ```\n\n You can also write your own training loop:\n\n ```\n @tf.function\n def train_step(iterator):\n\n def step_fn(inputs):\n features, labels = inputs\n with tf.GradientTape() as tape:\n logits = model(features, training=True)\n loss = tf.keras.losses.sparse_categorical_crossentropy(\n labels, logits)\n\n grads = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(zip(grads, model.trainable_variables))\n\n strategy.run(step_fn, args=(next(iterator),))\n\n for _ in range(NUM_STEP):\n train_step(iterator)\n ```\n\n See\n [Multi-worker training with Keras](https://www.tensorflow.org/tutorials/distribute/multi_worker_with_keras)\n for a detailed tutorial.\n\n __Saving__\n\n You need to save and checkpoint on all workers instead of just one. This is\n because variables whose synchronization=ON_READ triggers aggregation during\n saving. It's recommended to save to a different path on each worker to avoid\n race conditions. Each worker saves the same thing. See\n [Multi-worker training with Keras](https://www.tensorflow.org/tutorials/distribute/multi_worker_with_keras#model_saving_and_loading)\n tutorial for examples.\n\n __Known Issues__\n\n * `tf.distribute.cluster_resolver.TFConfigClusterResolver` does not return the\n correct number of accelerators. The strategy uses all available GPUs if\n `cluster_resolver` is `tf.distribute.cluster_resolver.TFConfigClusterResolver`\n or `None`.\n * In eager mode, the strategy needs to be created before calling any other\n Tensorflow API.\n\n ", "desc": "A distribution strategy for synchronous training on multiple workers.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.ParameterServerStrategy", "docs": "An asynchronous multi-worker parameter server tf.distribute strategy.\n\n This strategy requires two roles: workers and parameter servers. Variables and\n updates to those variables will be assigned to parameter servers and other\n operations are assigned to workers.\n\n When each worker has more than one GPU, operations will be replicated on all\n GPUs. Even though operations may be replicated, variables are not and each\n worker shares a common view for which parameter server a variable is assigned\n to.\n\n By default it uses `TFConfigClusterResolver` to detect configurations for\n multi-worker training. This requires a 'TF_CONFIG' environment variable and\n the 'TF_CONFIG' must have a cluster spec.\n\n This class assumes each worker is running the same code independently, but\n parameter servers are running a standard server. This means that while each\n worker will synchronously compute a single gradient update across all GPUs,\n updates between workers proceed asynchronously. Operations that occur only on\n the first replica (such as incrementing the global step), will occur on the\n first replica *of every worker*.\n\n It is expected to call `call_for_each_replica(fn, ...)` for any\n operations which potentially can be replicated across replicas (i.e. multiple\n GPUs) even if there is only CPU or one GPU. When defining the `fn`, extra\n caution needs to be taken:\n\n 1) It is generally not recommended to open a device scope under the strategy's\n scope. A device scope (i.e. calling `tf.device`) will be merged with or\n override the device for operations but will not change the device for\n variables.\n\n 2) It is also not recommended to open a colocation scope (i.e. calling\n `tf.compat.v1.colocate_with`) under the strategy's scope. For colocating\n variables, use `strategy.extended.colocate_vars_with` instead. Colocation of\n ops will possibly create device assignment conflicts.\n\n Note: This strategy only works with the Estimator API. Pass an instance of\n this strategy to the `experimental_distribute` argument when you create the\n `RunConfig`. This instance of `RunConfig` should then be passed to the\n `Estimator` instance on which `train_and_evaluate` is called.\n\n For Example:\n ```\n strategy = tf.distribute.experimental.ParameterServerStrategy()\n run_config = tf.estimator.RunConfig(\n experimental_distribute.train_distribute=strategy)\n estimator = tf.estimator.Estimator(config=run_config)\n tf.estimator.train_and_evaluate(estimator,...)\n ```\n ", "desc": "An asynchronous multi-worker parameter server tf.distribute strategy.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental.TPUStrategy", "docs": "TPU distribution strategy implementation.", "desc": "TPU distribution strategy implementation.", "type": "API"}, {"name": "tf.compat.v1.distribute.experimental_set_strategy", "docs": "Set a `tf.distribute.Strategy` as current without `with strategy.scope()`.\n\n ```\n tf.distribute.experimental_set_strategy(strategy1)\n f()\n tf.distribute.experimental_set_strategy(strategy2)\n g()\n tf.distribute.experimental_set_strategy(None)\n h()\n ```\n\n is equivalent to:\n\n ```\n with strategy1.scope():\n f()\n with strategy2.scope():\n g()\n h()\n ```\n\n In general, you should use the `with strategy.scope():` API, but this\n alternative may be convenient in notebooks where you would have to put\n each cell in a `with strategy.scope():` block.\n\n Note: This should only be called outside of any TensorFlow scope to\n avoid improper nesting.\n\n Args:\n strategy: A `tf.distribute.Strategy` object or None.\n\n Raises:\n RuntimeError: If called inside a `with strategy.scope():`.\n ", "desc": "Set a `tf.distribute.Strategy` as current without `with strategy.scope()`.", "type": "API"}, {"name": "tf.compat.v1.distribute.get_loss_reduction", "docs": "`tf.distribute.ReduceOp` corresponding to the last loss reduction.\n\n This is used to decide whether loss should be scaled in optimizer (used only\n for estimator + v1 optimizer use case).\n\n Returns:\n `tf.distribute.ReduceOp` corresponding to the last loss reduction for\n estimator and v1 optimizer use case. `tf.distribute.ReduceOp.SUM` otherwise.\n ", "desc": "`tf.distribute.ReduceOp` corresponding to the last loss reduction.", "type": "API"}, {"name": "tf.compat.v1.distribute.get_replica_context", "docs": "Returns the current `tf.distribute.ReplicaContext` or `None`.\n\n Returns `None` if in a cross-replica context.\n\n Note that execution:\n\n 1. starts in the default (single-replica) replica context (this function\n will return the default `ReplicaContext` object);\n 2. switches to cross-replica context (in which case this will return\n `None`) when entering a `with tf.distribute.Strategy.scope():` block;\n 3. switches to a (non-default) replica context inside `strategy.run(fn, ...)`;\n 4. if `fn` calls `get_replica_context().merge_call(merge_fn, ...)`, then\n inside `merge_fn` you are back in the cross-replica context (and again\n this function will return `None`).\n\n Most `tf.distribute.Strategy` methods may only be executed in\n a cross-replica context, in a replica context you should use the\n API of the `tf.distribute.ReplicaContext` object returned by this\n method instead.\n\n ```\n assert tf.distribute.get_replica_context() is not None # default\n with strategy.scope():\n assert tf.distribute.get_replica_context() is None\n\n def f():\n replica_context = tf.distribute.get_replica_context() # for strategy\n assert replica_context is not None\n tf.print(\"Replica id: \", replica_context.replica_id_in_sync_group,\n \" of \", replica_context.num_replicas_in_sync)\n\n strategy.run(f)\n ```\n\n Returns:\n The current `tf.distribute.ReplicaContext` object when in a replica context\n scope, else `None`.\n\n Within a particular block, exactly one of these two things will be true:\n\n * `get_replica_context()` returns non-`None`, or\n * `tf.distribute.is_cross_replica_context()` returns True.\n ", "desc": "Returns the current `tf.distribute.ReplicaContext` or `None`.", "type": "API"}, {"name": "tf.compat.v1.distribute.get_strategy", "docs": "Returns the current `tf.distribute.Strategy` object.\n\n Typically only used in a cross-replica context:\n\n ```\n if tf.distribute.in_cross_replica_context():\n strategy = tf.distribute.get_strategy()\n ...\n ```\n\n Returns:\n A `tf.distribute.Strategy` object. Inside a `with strategy.scope()` block,\n it returns `strategy`, otherwise it returns the default (single-replica)\n `tf.distribute.Strategy` object.\n ", "desc": "Returns the current `tf.distribute.Strategy` object.", "type": "API"}, {"name": "tf.compat.v1.distribute.has_strategy", "docs": "Return if there is a current non-default `tf.distribute.Strategy`.\n\n ```\n assert not tf.distribute.has_strategy()\n with strategy.scope():\n assert tf.distribute.has_strategy()\n ```\n\n Returns:\n True if inside a `with strategy.scope():`.\n ", "desc": "Return if there is a current non-default `tf.distribute.Strategy`.", "type": "API"}, {"name": "tf.compat.v1.distribute.HierarchicalCopyAllReduce", "docs": "Hierarchical copy all-reduce implementation of CrossDeviceOps.\n\n It reduces to one GPU along edges in some hierarchy and broadcasts back to\n each GPU along the same path. For the batch API, tensors will be repacked or\n aggregated for more efficient cross-device transportation.\n\n This is a reduction created for Nvidia DGX-1 which assumes GPUs connects like\n that on DGX-1 machine. If you have different GPU inter-connections, it is\n likely that it would be slower than `tf.distribute.ReductionToOneDevice`.\n\n For reduces that are not all-reduce, it falls back to\n `tf.distribute.ReductionToOneDevice`.\n\n Here is how you can use `HierarchicalCopyAllReduce` in\n `tf.distribute.MirroredStrategy`:\n\n ```\n strategy = tf.distribute.MirroredStrategy(\n cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())\n ```\n ", "desc": "Hierarchical copy all-reduce implementation of CrossDeviceOps.", "type": "API"}, {"name": "tf.compat.v1.distribute.in_cross_replica_context", "docs": "Returns `True` if in a cross-replica context.\n\n See `tf.distribute.get_replica_context` for details.\n\n ```\n assert not tf.distribute.in_cross_replica_context()\n with strategy.scope():\n assert tf.distribute.in_cross_replica_context()\n\n def f():\n assert not tf.distribute.in_cross_replica_context()\n\n strategy.run(f)\n ```\n\n Returns:\n `True` if in a cross-replica context (`get_replica_context()` returns\n `None`), or `False` if in a replica context (`get_replica_context()` returns\n non-`None`).\n ", "desc": "Returns `True` if in a cross-replica context.", "type": "API"}, {"name": "tf.compat.v1.distribute.InputContext", "docs": "A class wrapping information needed by an input function.\n\n This is a context class that is passed to the user's input function and\n contains information about the compute replicas and input pipelines. The\n number of compute replicas (in sync training) helps compute the local batch\n size from the desired global batch size for each replica. The input pipeline\n information can be used to return a different subset of the input in each\n replica (for e.g. shard the input pipeline, use a different input\n source etc).\n ", "desc": "A class wrapping information needed by an input function.", "type": "API"}, {"name": "tf.compat.v1.distribute.InputReplicationMode", "docs": "Replication mode for input function.\n\n * `PER_WORKER`: The input function will be called on each worker\n independently, creating as many input pipelines as number of workers.\n Replicas will dequeue from the local Dataset on their worker.\n `tf.distribute.Strategy` doesn't manage any state sharing between such\n separate input pipelines.\n * `PER_REPLICA`: The input function will be called on each replica separately.\n `tf.distribute.Strategy` doesn't manage any state sharing between such\n separate input pipelines.\n ", "desc": "Replication mode for input function.", "type": "API"}, {"name": "tf.compat.v1.distribute.MirroredStrategy", "docs": "Synchronous training across multiple replicas on one machine.\n\n This strategy is typically used for training on one\n machine with multiple GPUs. For TPUs, use\n `tf.distribute.TPUStrategy`. To use `MirroredStrategy` with multiple workers,\n please refer to `tf.distribute.experimental.MultiWorkerMirroredStrategy`.\n\n For example, a variable created under a `MirroredStrategy` is a\n `MirroredVariable`. If no devices are specified in the constructor argument of\n the strategy then it will use all the available GPUs. If no GPUs are found, it\n will use the available CPUs. Note that TensorFlow treats all CPUs on a\n machine as a single device, and uses threads internally for parallelism.\n\n >>> strategy = tf.distribute.MirroredStrategy([\"GPU:0\", \"GPU:1\"])\n >>> with strategy.scope():\n ... x = tf.Variable(1.)\n >>> x\n MirroredVariable:{\n 0: ,\n 1: \n }\n\n While using distribution strategies, all the variable creation should be done\n within the strategy's scope. This will replicate the variables across all the\n replicas and keep them in sync using an all-reduce algorithm.\n\n Variables created inside a `MirroredStrategy` which is wrapped with a\n `tf.function` are still `MirroredVariables`.\n\n >>> x = []\n >>> @tf.function # Wrap the function with tf.function.\n ... def create_variable():\n ... if not x:\n ... x.append(tf.Variable(1.))\n ... return x[0]\n >>> strategy = tf.distribute.MirroredStrategy([\"GPU:0\", \"GPU:1\"])\n >>> with strategy.scope():\n ... _ = create_variable()\n ... print(x[0])\n MirroredVariable:{\n 0: ,\n 1: \n }\n\n `experimental_distribute_dataset` can be used to distribute the dataset across\n the replicas when writing your own training loop. If you are using `.fit` and\n `.compile` methods available in `tf.keras`, then `tf.keras` will handle the\n distribution for you.\n\n For example:\n\n ```python\n my_strategy = tf.distribute.MirroredStrategy()\n with my_strategy.scope():\n @tf.function\n def distribute_train_epoch(dataset):\n def replica_fn(input):\n # process input and return result\n return result\n\n total_result = 0\n for x in dataset:\n per_replica_result = my_strategy.run(replica_fn, args=(x,))\n total_result += my_strategy.reduce(tf.distribute.ReduceOp.SUM,\n per_replica_result, axis=None)\n return total_result\n\n dist_dataset = my_strategy.experimental_distribute_dataset(dataset)\n for _ in range(EPOCHS):\n train_result = distribute_train_epoch(dist_dataset)\n ```\n\n Args:\n devices: a list of device strings such as `['/gpu:0', '/gpu:1']`. If\n `None`, all available GPUs are used. If no GPUs are found, CPU is used.\n cross_device_ops: optional, a descedant of `CrossDeviceOps`. If this is not\n set, `NcclAllReduce()` will be used by default. One would customize this\n if NCCL isn't available or if a special implementation that exploits\n the particular hardware is available.\n ", "desc": "Synchronous training across multiple replicas on one machine.", "type": "API"}, {"name": "tf.compat.v1.distribute.NcclAllReduce", "docs": "NCCL all-reduce implementation of CrossDeviceOps.\n\n It uses Nvidia NCCL for all-reduce. For the batch API, tensors will be\n repacked or aggregated for more efficient cross-device transportation.\n\n For reduces that are not all-reduce, it falls back to\n `tf.distribute.ReductionToOneDevice`.\n\n Here is how you can use `NcclAllReduce` in `tf.distribute.MirroredStrategy`:\n\n\n ```\n strategy = tf.distribute.MirroredStrategy(\n cross_device_ops=tf.distribute.NcclAllReduce())\n ```\n ", "desc": "NCCL all-reduce implementation of CrossDeviceOps.", "type": "API"}, {"name": "tf.compat.v1.distribute.OneDeviceStrategy", "docs": "A distribution strategy for running on a single device.\n\n Using this strategy will place any variables created in its scope on the\n specified device. Input distributed through this strategy will be\n prefetched to the specified device. Moreover, any functions called via\n `strategy.run` will also be placed on the specified device\n as well.\n\n Typical usage of this strategy could be testing your code with the\n tf.distribute.Strategy API before switching to other strategies which\n actually distribute to multiple devices/machines.\n\n For example:\n ```\n tf.enable_eager_execution()\n strategy = tf.distribute.OneDeviceStrategy(device=\"/gpu:0\")\n\n with strategy.scope():\n v = tf.Variable(1.0)\n print(v.device) # /job:localhost/replica:0/task:0/device:GPU:0\n\n def step_fn(x):\n return x * 2\n\n result = 0\n for i in range(10):\n result += strategy.run(step_fn, args=(i,))\n print(result) # 90\n ```\n ", "desc": "A distribution strategy for running on a single device.", "type": "API"}, {"name": "tf.compat.v1.distribute.ReduceOp", "docs": "Indicates how a set of values should be reduced.\n\n * `SUM`: Add all the values.\n * `MEAN`: Take the arithmetic mean (\"average\") of the values.\n ", "desc": "Indicates how a set of values should be reduced.", "type": "API"}, {"name": "tf.compat.v1.distribute.ReductionToOneDevice", "docs": "A CrossDeviceOps implementation that copies values to one device to reduce.\n\n This implementation always copies values to one device to reduce them, then\n broadcast reduced values to the destinations. It doesn't support efficient\n batching.\n\n Here is how you can use `ReductionToOneDevice` in\n `tf.distribute.MirroredStrategy`:\n\n ```\n strategy = tf.distribute.MirroredStrategy(\n cross_device_ops=tf.distribute.ReductionToOneDevice())\n ```\n ", "desc": "A CrossDeviceOps implementation that copies values to one device to reduce.", "type": "API"}, {"name": "tf.compat.v1.distribute.ReplicaContext", "docs": "A class with a collection of APIs that can be called in a replica context.\n\n You can use `tf.distribute.get_replica_context` to get an instance of\n `ReplicaContext`, which can only be called inside the function passed to\n `tf.distribute.Strategy.run`.\n\n >>> strategy = tf.distribute.MirroredStrategy(['GPU:0', 'GPU:1'])\n >>> def func():\n ... replica_context = tf.distribute.get_replica_context()\n ... return replica_context.replica_id_in_sync_group\n >>> strategy.run(func)\n PerReplica:{\n 0: ,\n 1: \n }\n ", "desc": "A class with a collection of APIs that can be called in a replica context.", "type": "API"}, {"name": "tf.compat.v1.distribute.RunOptions", "docs": "Run options for `strategy.run`.\n\n This can be used to hold some strategy specific configs.\n\n Attributes:\n experimental_enable_dynamic_batch_size: Boolean. Only applies to\n TPUStrategy. Default to True. If True, TPUStrategy will enable dynamic\n padder to support dynamic batch size for the inputs. Otherwise only static\n shape inputs are allowed.\n experimental_bucketizing_dynamic_shape: Boolean. Only applies to\n TPUStrategy. Default to False. If True, TPUStrategy will automatic\n bucketize inputs passed into `run` if the input shape is\n dynamic. This is a performance optimization to reduce XLA recompilation,\n which should not have impact on correctness.\n experimental_xla_options: A `tf.tpu.XLAOptions` instance. Only applies to\n TPUStrategy. Controls the XLA compiling options on TPUs. Default to None.\n ", "desc": "Run options for `strategy.run`.", "type": "API"}, {"name": "tf.compat.v1.distribute.Server", "docs": "An in-process TensorFlow server, for use in distributed training.\n\n A `tf.distribute.Server` instance encapsulates a set of devices and a\n `tf.compat.v1.Session` target that\n can participate in distributed training. A server belongs to a\n cluster (specified by a `tf.train.ClusterSpec`), and\n corresponds to a particular task in a named job. The server can\n communicate with any other server in the same cluster.\n ", "desc": "An in-process TensorFlow server, for use in distributed training.", "type": "API"}, {"name": "tf.compat.v1.distribute.Strategy", "docs": "A list of devices with a state & compute distribution policy.\n\n See [the guide](https://www.tensorflow.org/guide/distribute_strategy)\n for overview and examples.\n\n Note: Not all `tf.distribute.Strategy` implementations currently support\n TensorFlow's partitioned variables (where a single variable is split across\n multiple devices) at this time.\n ", "desc": "A list of devices with a state & compute distribution policy.", "type": "API"}, {"name": "tf.compat.v1.distribute.StrategyExtended", "docs": "Additional APIs for algorithms that need to be distribution-aware.\n\n Note: For most usage of `tf.distribute.Strategy`, there should be no need to\n call these methods, since TensorFlow libraries (such as optimizers) already\n call these methods when needed on your behalf.\n\n\n Some common use cases of functions on this page:\n\n * _Locality_\n\n `tf.distribute.DistributedValues` can have the same _locality_ as a\n _distributed variable_, which leads to a mirrored value residing on the same\n devices as the variable (as opposed to the compute devices). Such values may\n be passed to a call to `tf.distribute.StrategyExtended.update` to update the\n value of a variable. You may use\n `tf.distribute.StrategyExtended.colocate_vars_with` to give a variable the\n same locality as another variable. You may convert a \"PerReplica\" value to a\n variable's locality by using `tf.distribute.StrategyExtended.reduce_to` or\n `tf.distribute.StrategyExtended.batch_reduce_to`.\n\n * _How to update a distributed variable_\n\n A distributed variable is variables created on multiple devices. As discussed\n in the [glossary](https://www.tensorflow.org/api_docs/python/tf/distribute),\n mirrored variable and SyncOnRead variable are two examples. The standard\n pattern for updating distributed variables is to:\n\n 1. In your function passed to `tf.distribute.Strategy.run`,\n compute a list of (update, variable) pairs. For example, the update might\n be a gradient of the loss with respect to the variable.\n 2. Switch to cross-replica mode by calling\n `tf.distribute.get_replica_context().merge_call()` with the updates and\n variables as arguments.\n 3. Call\n `tf.distribute.StrategyExtended.reduce_to(VariableAggregation.SUM, t, v)`\n (for one variable) or `tf.distribute.StrategyExtended.batch_reduce_to`\n (for a list of variables) to sum the updates.\n 4. Call `tf.distribute.StrategyExtended.update(v)` for each variable to update\n its value.\n\n Steps 2 through 4 are done automatically by class\n `tf.keras.optimizers.Optimizer` if you call its\n `tf.keras.optimizers.Optimizer.apply_gradients` method in a replica context.\n\n In fact, a higher-level solution to update a distributed variable is by\n calling `assign` on the variable as you would do to a regular `tf.Variable`.\n You can call the method in both _replica context_ and _cross-replica context_.\n For a _mirrored variable_, calling `assign` in _replica context_ requires you\n to specify the `aggregation` type in the variable constructor. In that case,\n the context switching and sync described in steps 2 through 4 are handled for\n you. If you call `assign` on _mirrored variable_ in _cross-replica context_,\n you can only assign a single value or assign values from another mirrored\n variable or a mirrored `tf.distribute.DistributedValues`. For a _SyncOnRead\n variable_, in _replica context_, you can simply call `assign` on it and no\n aggregation happens under the hood. In _cross-replica context_, you can only\n assign a single value to a SyncOnRead variable. One example case is restoring\n from a checkpoint: if the `aggregation` type of the variable is\n `tf.VariableAggregation.SUM`, it is assumed that replica values were added\n before checkpointing, so at the time of restoring, the value is divided by\n the number of replicas and then assigned to each replica; if the `aggregation`\n type is `tf.VariableAggregation.MEAN`, the value is assigned to each replica\n directly.\n\n ", "desc": "Additional APIs for algorithms that need to be distribution-aware.", "type": "API"}, {"name": "tf.compat.v1.distributions", "docs": "Core module for TensorFlow distribution objects and helpers.\n", "desc": "Core module for TensorFlow distribution objects and helpers.", "type": "API"}, {"name": "tf.compat.v1.distributions.Bernoulli", "docs": "Bernoulli distribution.\n\n The Bernoulli distribution with `probs` parameter, i.e., the probability of a\n `1` outcome (vs a `0` outcome).\n ", "desc": "Bernoulli distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Beta", "docs": "Beta distribution.\n\n The Beta distribution is defined over the `(0, 1)` interval using parameters\n `concentration1` (aka \"alpha\") and `concentration0` (aka \"beta\").\n\n #### Mathematical Details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; alpha, beta) = x**(alpha - 1) (1 - x)**(beta - 1) / Z\n Z = Gamma(alpha) Gamma(beta) / Gamma(alpha + beta)\n ```\n\n where:\n\n * `concentration1 = alpha`,\n * `concentration0 = beta`,\n * `Z` is the normalization constant, and,\n * `Gamma` is the [gamma function](\n https://en.wikipedia.org/wiki/Gamma_function).\n\n The concentration parameters represent mean total counts of a `1` or a `0`,\n i.e.,\n\n ```none\n concentration1 = alpha = mean * total_concentration\n concentration0 = beta = (1. - mean) * total_concentration\n ```\n\n where `mean` in `(0, 1)` and `total_concentration` is a positive real number\n representing a mean `total_count = concentration1 + concentration0`.\n\n Distribution parameters are automatically broadcast in all functions; see\n examples for details.\n\n Warning: The samples can be zero due to finite precision.\n This happens more often when some of the concentrations are very small.\n Make sure to round the samples to `np.finfo(dtype).tiny` before computing the\n density.\n\n Samples of this distribution are reparameterized (pathwise differentiable).\n The derivatives are computed using the approach described in\n (Figurnov et al., 2018).\n\n #### Examples\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n # Create a batch of three Beta distributions.\n alpha = [1, 2, 3]\n beta = [1, 2, 3]\n dist = tfd.Beta(alpha, beta)\n\n dist.sample([4, 5]) # Shape [4, 5, 3]\n\n # `x` has three batch entries, each with two samples.\n x = [[.1, .4, .5],\n [.2, .3, .5]]\n # Calculate the probability of each pair of samples under the corresponding\n # distribution in `dist`.\n dist.prob(x) # Shape [2, 3]\n ```\n\n ```python\n # Create batch_shape=[2, 3] via parameter broadcast:\n alpha = [[1.], [2]] # Shape [2, 1]\n beta = [3., 4, 5] # Shape [3]\n dist = tfd.Beta(alpha, beta)\n\n # alpha broadcast as: [[1., 1, 1,],\n # [2, 2, 2]]\n # beta broadcast as: [[3., 4, 5],\n # [3, 4, 5]]\n # batch_Shape [2, 3]\n dist.sample([4, 5]) # Shape [4, 5, 2, 3]\n\n x = [.2, .3, .5]\n # x will be broadcast as [[.2, .3, .5],\n # [.2, .3, .5]],\n # thus matching batch_shape [2, 3].\n dist.prob(x) # Shape [2, 3]\n ```\n\n Compute the gradients of samples w.r.t. the parameters:\n\n ```python\n alpha = tf.constant(1.0)\n beta = tf.constant(2.0)\n dist = tfd.Beta(alpha, beta)\n samples = dist.sample(5) # Shape [5]\n loss = tf.reduce_mean(tf.square(samples)) # Arbitrary loss function\n # Unbiased stochastic gradients of the loss function\n grads = tf.gradients(loss, [alpha, beta])\n ```\n\n References:\n Implicit Reparameterization Gradients:\n [Figurnov et al., 2018]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients)\n ([pdf]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients.pdf))\n ", "desc": "Beta distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Categorical", "docs": "Categorical distribution.\n\n The Categorical distribution is parameterized by either probabilities or\n log-probabilities of a set of `K` classes. It is defined over the integers\n `{0, 1, ..., K}`.\n\n The Categorical distribution is closely related to the `OneHotCategorical` and\n `Multinomial` distributions. The Categorical distribution can be intuited as\n generating samples according to `argmax{ OneHotCategorical(probs) }` itself\n being identical to `argmax{ Multinomial(probs, total_count=1) }`.\n\n #### Mathematical Details\n\n The probability mass function (pmf) is,\n\n ```none\n pmf(k; pi) = prod_j pi_j**[k == j]\n ```\n\n #### Pitfalls\n\n The number of classes, `K`, must not exceed:\n - the largest integer representable by `self.dtype`, i.e.,\n `2**(mantissa_bits+1)` (IEEE 754),\n - the maximum `Tensor` index, i.e., `2**31-1`.\n\n In other words,\n\n ```python\n K <= min(2**31-1, {\n tf.float16: 2**11,\n tf.float32: 2**24,\n tf.float64: 2**53 }[param.dtype])\n ```\n\n Note: This condition is validated only when `self.validate_args = True`.\n\n #### Examples\n\n Creates a 3-class distribution with the 2nd class being most likely.\n\n ```python\n dist = Categorical(probs=[0.1, 0.5, 0.4])\n n = 1e4\n empirical_prob = tf.cast(\n tf.histogram_fixed_width(\n dist.sample(int(n)),\n [0., 2],\n nbins=3),\n dtype=tf.float32) / n\n # ==> array([ 0.1005, 0.5037, 0.3958], dtype=float32)\n ```\n\n Creates a 3-class distribution with the 2nd class being most likely.\n Parameterized by [logits](https://en.wikipedia.org/wiki/Logit) rather than\n probabilities.\n\n ```python\n dist = Categorical(logits=np.log([0.1, 0.5, 0.4])\n n = 1e4\n empirical_prob = tf.cast(\n tf.histogram_fixed_width(\n dist.sample(int(n)),\n [0., 2],\n nbins=3),\n dtype=tf.float32) / n\n # ==> array([0.1045, 0.5047, 0.3908], dtype=float32)\n ```\n\n Creates a 3-class distribution with the 3rd class being most likely.\n The distribution functions can be evaluated on counts.\n\n ```python\n # counts is a scalar.\n p = [0.1, 0.4, 0.5]\n dist = Categorical(probs=p)\n dist.prob(0) # Shape []\n\n # p will be broadcast to [[0.1, 0.4, 0.5], [0.1, 0.4, 0.5]] to match counts.\n counts = [1, 0]\n dist.prob(counts) # Shape [2]\n\n # p will be broadcast to shape [3, 5, 7, 3] to match counts.\n counts = [[...]] # Shape [5, 7, 3]\n dist.prob(counts) # Shape [5, 7, 3]\n ```\n\n ", "desc": "Categorical distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Dirichlet", "docs": "Dirichlet distribution.\n\n The Dirichlet distribution is defined over the\n [`(k-1)`-simplex](https://en.wikipedia.org/wiki/Simplex) using a positive,\n length-`k` vector `concentration` (`k > 1`). The Dirichlet is identically the\n Beta distribution when `k = 2`.\n\n #### Mathematical Details\n\n The Dirichlet is a distribution over the open `(k-1)`-simplex, i.e.,\n\n ```none\n S^{k-1} = { (x_0, ..., x_{k-1}) in R^k : sum_j x_j = 1 and all_j x_j > 0 }.\n ```\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; alpha) = prod_j x_j**(alpha_j - 1) / Z\n Z = prod_j Gamma(alpha_j) / Gamma(sum_j alpha_j)\n ```\n\n where:\n\n * `x in S^{k-1}`, i.e., the `(k-1)`-simplex,\n * `concentration = alpha = [alpha_0, ..., alpha_{k-1}]`, `alpha_j > 0`,\n * `Z` is the normalization constant aka the [multivariate beta function](\n https://en.wikipedia.org/wiki/Beta_function#Multivariate_beta_function),\n and,\n * `Gamma` is the [gamma function](\n https://en.wikipedia.org/wiki/Gamma_function).\n\n The `concentration` represents mean total counts of class occurrence, i.e.,\n\n ```none\n concentration = alpha = mean * total_concentration\n ```\n\n where `mean` in `S^{k-1}` and `total_concentration` is a positive real number\n representing a mean total count.\n\n Distribution parameters are automatically broadcast in all functions; see\n examples for details.\n\n Warning: Some components of the samples can be zero due to finite precision.\n This happens more often when some of the concentrations are very small.\n Make sure to round the samples to `np.finfo(dtype).tiny` before computing the\n density.\n\n Samples of this distribution are reparameterized (pathwise differentiable).\n The derivatives are computed using the approach described in\n (Figurnov et al., 2018).\n\n #### Examples\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n # Create a single trivariate Dirichlet, with the 3rd class being three times\n # more frequent than the first. I.e., batch_shape=[], event_shape=[3].\n alpha = [1., 2, 3]\n dist = tfd.Dirichlet(alpha)\n\n dist.sample([4, 5]) # shape: [4, 5, 3]\n\n # x has one sample, one batch, three classes:\n x = [.2, .3, .5] # shape: [3]\n dist.prob(x) # shape: []\n\n # x has two samples from one batch:\n x = [[.1, .4, .5],\n [.2, .3, .5]]\n dist.prob(x) # shape: [2]\n\n # alpha will be broadcast to shape [5, 7, 3] to match x.\n x = [[...]] # shape: [5, 7, 3]\n dist.prob(x) # shape: [5, 7]\n ```\n\n ```python\n # Create batch_shape=[2], event_shape=[3]:\n alpha = [[1., 2, 3],\n [4, 5, 6]] # shape: [2, 3]\n dist = tfd.Dirichlet(alpha)\n\n dist.sample([4, 5]) # shape: [4, 5, 2, 3]\n\n x = [.2, .3, .5]\n # x will be broadcast as [[.2, .3, .5],\n # [.2, .3, .5]],\n # thus matching batch_shape [2, 3].\n dist.prob(x) # shape: [2]\n ```\n\n Compute the gradients of samples w.r.t. the parameters:\n\n ```python\n alpha = tf.constant([1.0, 2.0, 3.0])\n dist = tfd.Dirichlet(alpha)\n samples = dist.sample(5) # Shape [5, 3]\n loss = tf.reduce_mean(tf.square(samples)) # Arbitrary loss function\n # Unbiased stochastic gradients of the loss function\n grads = tf.gradients(loss, alpha)\n ```\n\n References:\n Implicit Reparameterization Gradients:\n [Figurnov et al., 2018]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients)\n ([pdf]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients.pdf))\n ", "desc": "Dirichlet distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.DirichletMultinomial", "docs": "Dirichlet-Multinomial compound distribution.\n\n The Dirichlet-Multinomial distribution is parameterized by a (batch of)\n length-`K` `concentration` vectors (`K > 1`) and a `total_count` number of\n trials, i.e., the number of trials per draw from the DirichletMultinomial. It\n is defined over a (batch of) length-`K` vector `counts` such that\n `tf.reduce_sum(counts, -1) = total_count`. The Dirichlet-Multinomial is\n identically the Beta-Binomial distribution when `K = 2`.\n\n #### Mathematical Details\n\n The Dirichlet-Multinomial is a distribution over `K`-class counts, i.e., a\n length-`K` vector of non-negative integer `counts = n = [n_0, ..., n_{K-1}]`.\n\n The probability mass function (pmf) is,\n\n ```none\n pmf(n; alpha, N) = Beta(alpha + n) / (prod_j n_j!) / Z\n Z = Beta(alpha) / N!\n ```\n\n where:\n\n * `concentration = alpha = [alpha_0, ..., alpha_{K-1}]`, `alpha_j > 0`,\n * `total_count = N`, `N` a positive integer,\n * `N!` is `N` factorial, and,\n * `Beta(x) = prod_j Gamma(x_j) / Gamma(sum_j x_j)` is the\n [multivariate beta function](\n https://en.wikipedia.org/wiki/Beta_function#Multivariate_beta_function),\n and,\n * `Gamma` is the [gamma function](\n https://en.wikipedia.org/wiki/Gamma_function).\n\n Dirichlet-Multinomial is a [compound distribution](\n https://en.wikipedia.org/wiki/Compound_probability_distribution), i.e., its\n samples are generated as follows.\n\n 1. Choose class probabilities:\n `probs = [p_0,...,p_{K-1}] ~ Dir(concentration)`\n 2. Draw integers:\n `counts = [n_0,...,n_{K-1}] ~ Multinomial(total_count, probs)`\n\n The last `concentration` dimension parametrizes a single Dirichlet-Multinomial\n distribution. When calling distribution functions (e.g., `dist.prob(counts)`),\n `concentration`, `total_count` and `counts` are broadcast to the same shape.\n The last dimension of `counts` corresponds single Dirichlet-Multinomial\n distributions.\n\n Distribution parameters are automatically broadcast in all functions; see\n examples for details.\n\n #### Pitfalls\n\n The number of classes, `K`, must not exceed:\n - the largest integer representable by `self.dtype`, i.e.,\n `2**(mantissa_bits+1)` (IEE754),\n - the maximum `Tensor` index, i.e., `2**31-1`.\n\n In other words,\n\n ```python\n K <= min(2**31-1, {\n tf.float16: 2**11,\n tf.float32: 2**24,\n tf.float64: 2**53 }[param.dtype])\n ```\n\n Note: This condition is validated only when `self.validate_args = True`.\n\n #### Examples\n\n ```python\n alpha = [1., 2., 3.]\n n = 2.\n dist = DirichletMultinomial(n, alpha)\n ```\n\n Creates a 3-class distribution, with the 3rd class is most likely to be\n drawn.\n The distribution functions can be evaluated on counts.\n\n ```python\n # counts same shape as alpha.\n counts = [0., 0., 2.]\n dist.prob(counts) # Shape []\n\n # alpha will be broadcast to [[1., 2., 3.], [1., 2., 3.]] to match counts.\n counts = [[1., 1., 0.], [1., 0., 1.]]\n dist.prob(counts) # Shape [2]\n\n # alpha will be broadcast to shape [5, 7, 3] to match counts.\n counts = [[...]] # Shape [5, 7, 3]\n dist.prob(counts) # Shape [5, 7]\n ```\n\n Creates a 2-batch of 3-class distributions.\n\n ```python\n alpha = [[1., 2., 3.], [4., 5., 6.]] # Shape [2, 3]\n n = [3., 3.]\n dist = DirichletMultinomial(n, alpha)\n\n # counts will be broadcast to [[2., 1., 0.], [2., 1., 0.]] to match alpha.\n counts = [2., 1., 0.]\n dist.prob(counts) # Shape [2]\n ```\n\n ", "desc": "Dirichlet-Multinomial compound distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Distribution", "docs": "A generic probability distribution base class.\n\n `Distribution` is a base class for constructing and organizing properties\n (e.g., mean, variance) of random variables (e.g, Bernoulli, Gaussian).\n\n #### Subclassing\n\n Subclasses are expected to implement a leading-underscore version of the\n same-named function. The argument signature should be identical except for\n the omission of `name=\"...\"`. For example, to enable `log_prob(value,\n name=\"log_prob\")` a subclass should implement `_log_prob(value)`.\n\n Subclasses can append to public-level docstrings by providing\n docstrings for their method specializations. For example:\n\n ```python\n @util.AppendDocstring(\"Some other details.\")\n def _log_prob(self, value):\n ...\n ```\n\n would add the string \"Some other details.\" to the `log_prob` function\n docstring. This is implemented as a simple decorator to avoid python\n linter complaining about missing Args/Returns/Raises sections in the\n partial docstrings.\n\n #### Broadcasting, batching, and shapes\n\n All distributions support batches of independent distributions of that type.\n The batch shape is determined by broadcasting together the parameters.\n\n The shape of arguments to `__init__`, `cdf`, `log_cdf`, `prob`, and\n `log_prob` reflect this broadcasting, as does the return value of `sample` and\n `sample_n`.\n\n `sample_n_shape = [n] + batch_shape + event_shape`, where `sample_n_shape` is\n the shape of the `Tensor` returned from `sample_n`, `n` is the number of\n samples, `batch_shape` defines how many independent distributions there are,\n and `event_shape` defines the shape of samples from each of those independent\n distributions. Samples are independent along the `batch_shape` dimensions, but\n not necessarily so along the `event_shape` dimensions (depending on the\n particulars of the underlying distribution).\n\n Using the `Uniform` distribution as an example:\n\n ```python\n minval = 3.0\n maxval = [[4.0, 6.0],\n [10.0, 12.0]]\n\n # Broadcasting:\n # This instance represents 4 Uniform distributions. Each has a lower bound at\n # 3.0 as the `minval` parameter was broadcasted to match `maxval`'s shape.\n u = Uniform(minval, maxval)\n\n # `event_shape` is `TensorShape([])`.\n event_shape = u.event_shape\n # `event_shape_t` is a `Tensor` which will evaluate to [].\n event_shape_t = u.event_shape_tensor()\n\n # Sampling returns a sample per distribution. `samples` has shape\n # [5, 2, 2], which is [n] + batch_shape + event_shape, where n=5,\n # batch_shape=[2, 2], and event_shape=[].\n samples = u.sample_n(5)\n\n # The broadcasting holds across methods. Here we use `cdf` as an example. The\n # same holds for `log_cdf` and the likelihood functions.\n\n # `cum_prob` has shape [2, 2] as the `value` argument was broadcasted to the\n # shape of the `Uniform` instance.\n cum_prob_broadcast = u.cdf(4.0)\n\n # `cum_prob`'s shape is [2, 2], one per distribution. No broadcasting\n # occurred.\n cum_prob_per_dist = u.cdf([[4.0, 5.0],\n [6.0, 7.0]])\n\n # INVALID as the `value` argument is not broadcastable to the distribution's\n # shape.\n cum_prob_invalid = u.cdf([4.0, 5.0, 6.0])\n ```\n\n #### Shapes\n\n There are three important concepts associated with TensorFlow Distributions\n shapes:\n - Event shape describes the shape of a single draw from the distribution;\n it may be dependent across dimensions. For scalar distributions, the event\n shape is `[]`. For a 5-dimensional MultivariateNormal, the event shape is\n `[5]`.\n - Batch shape describes independent, not identically distributed draws, aka a\n \"collection\" or \"bunch\" of distributions.\n - Sample shape describes independent, identically distributed draws of batches\n from the distribution family.\n\n The event shape and the batch shape are properties of a Distribution object,\n whereas the sample shape is associated with a specific call to `sample` or\n `log_prob`.\n\n For detailed usage examples of TensorFlow Distributions shapes, see\n [this tutorial](\n https://github.com/tensorflow/probability/blob/master/tensorflow_probability/examples/jupyter_notebooks/Understanding_TensorFlow_Distributions_Shapes.ipynb)\n\n #### Parameter values leading to undefined statistics or distributions.\n\n Some distributions do not have well-defined statistics for all initialization\n parameter values. For example, the beta distribution is parameterized by\n positive real numbers `concentration1` and `concentration0`, and does not have\n well-defined mode if `concentration1 < 1` or `concentration0 < 1`.\n\n The user is given the option of raising an exception or returning `NaN`.\n\n ```python\n a = tf.exp(tf.matmul(logits, weights_a))\n b = tf.exp(tf.matmul(logits, weights_b))\n\n # Will raise exception if ANY batch member has a < 1 or b < 1.\n dist = distributions.beta(a, b, allow_nan_stats=False)\n mode = dist.mode().eval()\n\n # Will return NaN for batch members with either a < 1 or b < 1.\n dist = distributions.beta(a, b, allow_nan_stats=True) # Default behavior\n mode = dist.mode().eval()\n ```\n\n In all cases, an exception is raised if *invalid* parameters are passed, e.g.\n\n ```python\n # Will raise an exception if any Op is run.\n negative_a = -1.0 * a # beta distribution by definition has a > 0.\n dist = distributions.beta(negative_a, b, allow_nan_stats=True)\n dist.mean().eval()\n ```\n\n ", "desc": "A generic probability distribution base class.", "type": "API"}, {"name": "tf.compat.v1.distributions.Exponential", "docs": "Exponential distribution.\n\n The Exponential distribution is parameterized by an event `rate` parameter.\n\n #### Mathematical Details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; lambda, x > 0) = exp(-lambda x) / Z\n Z = 1 / lambda\n ```\n\n where `rate = lambda` and `Z` is the normalizaing constant.\n\n The Exponential distribution is a special case of the Gamma distribution,\n i.e.,\n\n ```python\n Exponential(rate) = Gamma(concentration=1., rate)\n ```\n\n The Exponential distribution uses a `rate` parameter, or \"inverse scale\",\n which can be intuited as,\n\n ```none\n X ~ Exponential(rate=1)\n Y = X / rate\n ```\n\n ", "desc": "Exponential distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Gamma", "docs": "Gamma distribution.\n\n The Gamma distribution is defined over positive real numbers using\n parameters `concentration` (aka \"alpha\") and `rate` (aka \"beta\").\n\n #### Mathematical Details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; alpha, beta, x > 0) = x**(alpha - 1) exp(-x beta) / Z\n Z = Gamma(alpha) beta**(-alpha)\n ```\n\n where:\n\n * `concentration = alpha`, `alpha > 0`,\n * `rate = beta`, `beta > 0`,\n * `Z` is the normalizing constant, and,\n * `Gamma` is the [gamma function](\n https://en.wikipedia.org/wiki/Gamma_function).\n\n The cumulative density function (cdf) is,\n\n ```none\n cdf(x; alpha, beta, x > 0) = GammaInc(alpha, beta x) / Gamma(alpha)\n ```\n\n where `GammaInc` is the [lower incomplete Gamma function](\n https://en.wikipedia.org/wiki/Incomplete_gamma_function).\n\n The parameters can be intuited via their relationship to mean and stddev,\n\n ```none\n concentration = alpha = (mean / stddev)**2\n rate = beta = mean / stddev**2 = concentration / mean\n ```\n\n Distribution parameters are automatically broadcast in all functions; see\n examples for details.\n\n Warning: The samples of this distribution are always non-negative. However,\n the samples that are smaller than `np.finfo(dtype).tiny` are rounded\n to this value, so it appears more often than it should.\n This should only be noticeable when the `concentration` is very small, or the\n `rate` is very large. See note in `tf.random.gamma` docstring.\n\n Samples of this distribution are reparameterized (pathwise differentiable).\n The derivatives are computed using the approach described in\n (Figurnov et al., 2018).\n\n #### Examples\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n dist = tfd.Gamma(concentration=3.0, rate=2.0)\n dist2 = tfd.Gamma(concentration=[3.0, 4.0], rate=[2.0, 3.0])\n ```\n\n Compute the gradients of samples w.r.t. the parameters:\n\n ```python\n concentration = tf.constant(3.0)\n rate = tf.constant(2.0)\n dist = tfd.Gamma(concentration, rate)\n samples = dist.sample(5) # Shape [5]\n loss = tf.reduce_mean(tf.square(samples)) # Arbitrary loss function\n # Unbiased stochastic gradients of the loss function\n grads = tf.gradients(loss, [concentration, rate])\n ```\n\n References:\n Implicit Reparameterization Gradients:\n [Figurnov et al., 2018]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients)\n ([pdf](http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients.pdf))\n ", "desc": "Gamma distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.kl_divergence", "docs": "Get the KL-divergence KL(distribution_a || distribution_b). (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed after 2019-01-01.\nInstructions for updating:\nThe TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.distributions`.\n\nIf there is no KL method registered specifically for `type(distribution_a)`\nand `type(distribution_b)`, then the class hierarchies of these types are\nsearched.\n\nIf one KL method is registered between any pairs of classes in these two\nparent hierarchies, it is used.\n\nIf more than one such registered method exists, the method whose registered\nclasses have the shortest sum MRO paths to the input types is used.\n\nIf more than one such shortest path exists, the first method\nidentified in the search is used (favoring a shorter MRO distance to\n`type(distribution_a)`).\n\nArgs:\n distribution_a: The first distribution.\n distribution_b: The second distribution.\n allow_nan_stats: Python `bool`, default `True`. When `True`,\n statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n indicate the result is undefined. When `False`, an exception is raised\n if one or more of the statistic's batch members are undefined.\n name: Python `str` name prefixed to Ops created by this class.\n\nReturns:\n A Tensor with the batchwise KL-divergence between `distribution_a`\n and `distribution_b`.\n\nRaises:\n NotImplementedError: If no KL method is defined for distribution types\n of `distribution_a` and `distribution_b`.", "desc": "Get the KL-divergence KL(distribution_a || distribution_b). (deprecated)", "type": "API"}, {"name": "tf.compat.v1.distributions.Laplace", "docs": "The Laplace distribution with location `loc` and `scale` parameters.\n\n #### Mathematical details\n\n The probability density function (pdf) of this distribution is,\n\n ```none\n pdf(x; mu, sigma) = exp(-|x - mu| / sigma) / Z\n Z = 2 sigma\n ```\n\n where `loc = mu`, `scale = sigma`, and `Z` is the normalization constant.\n\n Note that the Laplace distribution can be thought of two exponential\n distributions spliced together \"back-to-back.\"\n\n The Lpalce distribution is a member of the [location-scale family](\n https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be\n constructed as,\n\n ```none\n X ~ Laplace(loc=0, scale=1)\n Y = loc + scale * X\n ```\n\n ", "desc": "The Laplace distribution with location `loc` and `scale` parameters.", "type": "API"}, {"name": "tf.compat.v1.distributions.Multinomial", "docs": "Multinomial distribution.\n\n This Multinomial distribution is parameterized by `probs`, a (batch of)\n length-`K` `prob` (probability) vectors (`K > 1`) such that\n `tf.reduce_sum(probs, -1) = 1`, and a `total_count` number of trials, i.e.,\n the number of trials per draw from the Multinomial. It is defined over a\n (batch of) length-`K` vector `counts` such that\n `tf.reduce_sum(counts, -1) = total_count`. The Multinomial is identically the\n Binomial distribution when `K = 2`.\n\n #### Mathematical Details\n\n The Multinomial is a distribution over `K`-class counts, i.e., a length-`K`\n vector of non-negative integer `counts = n = [n_0, ..., n_{K-1}]`.\n\n The probability mass function (pmf) is,\n\n ```none\n pmf(n; pi, N) = prod_j (pi_j)**n_j / Z\n Z = (prod_j n_j!) / N!\n ```\n\n where:\n * `probs = pi = [pi_0, ..., pi_{K-1}]`, `pi_j > 0`, `sum_j pi_j = 1`,\n * `total_count = N`, `N` a positive integer,\n * `Z` is the normalization constant, and,\n * `N!` denotes `N` factorial.\n\n Distribution parameters are automatically broadcast in all functions; see\n examples for details.\n\n #### Pitfalls\n\n The number of classes, `K`, must not exceed:\n - the largest integer representable by `self.dtype`, i.e.,\n `2**(mantissa_bits+1)` (IEE754),\n - the maximum `Tensor` index, i.e., `2**31-1`.\n\n In other words,\n\n ```python\n K <= min(2**31-1, {\n tf.float16: 2**11,\n tf.float32: 2**24,\n tf.float64: 2**53 }[param.dtype])\n ```\n\n Note: This condition is validated only when `self.validate_args = True`.\n\n #### Examples\n\n Create a 3-class distribution, with the 3rd class is most likely to be drawn,\n using logits.\n\n ```python\n logits = [-50., -43, 0]\n dist = Multinomial(total_count=4., logits=logits)\n ```\n\n Create a 3-class distribution, with the 3rd class is most likely to be drawn.\n\n ```python\n p = [.2, .3, .5]\n dist = Multinomial(total_count=4., probs=p)\n ```\n\n The distribution functions can be evaluated on counts.\n\n ```python\n # counts same shape as p.\n counts = [1., 0, 3]\n dist.prob(counts) # Shape []\n\n # p will be broadcast to [[.2, .3, .5], [.2, .3, .5]] to match counts.\n counts = [[1., 2, 1], [2, 2, 0]]\n dist.prob(counts) # Shape [2]\n\n # p will be broadcast to shape [5, 7, 3] to match counts.\n counts = [[...]] # Shape [5, 7, 3]\n dist.prob(counts) # Shape [5, 7]\n ```\n\n Create a 2-batch of 3-class distributions.\n\n ```python\n p = [[.1, .2, .7], [.3, .3, .4]] # Shape [2, 3]\n dist = Multinomial(total_count=[4., 5], probs=p)\n\n counts = [[2., 1, 1], [3, 1, 1]]\n dist.prob(counts) # Shape [2]\n\n dist.sample(5) # Shape [5, 2, 3]\n ```\n ", "desc": "Multinomial distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Normal", "docs": "The Normal distribution with location `loc` and `scale` parameters.\n\n #### Mathematical details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; mu, sigma) = exp(-0.5 (x - mu)**2 / sigma**2) / Z\n Z = (2 pi sigma**2)**0.5\n ```\n\n where `loc = mu` is the mean, `scale = sigma` is the std. deviation, and, `Z`\n is the normalization constant.\n\n The Normal distribution is a member of the [location-scale family](\n https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be\n constructed as,\n\n ```none\n X ~ Normal(loc=0, scale=1)\n Y = loc + scale * X\n ```\n\n #### Examples\n\n Examples of initialization of one or a batch of distributions.\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n # Define a single scalar Normal distribution.\n dist = tfd.Normal(loc=0., scale=3.)\n\n # Evaluate the cdf at 1, returning a scalar.\n dist.cdf(1.)\n\n # Define a batch of two scalar valued Normals.\n # The first has mean 1 and standard deviation 11, the second 2 and 22.\n dist = tfd.Normal(loc=[1, 2.], scale=[11, 22.])\n\n # Evaluate the pdf of the first distribution on 0, and the second on 1.5,\n # returning a length two tensor.\n dist.prob([0, 1.5])\n\n # Get 3 samples, returning a 3 x 2 tensor.\n dist.sample([3])\n ```\n\n Arguments are broadcast when possible.\n\n ```python\n # Define a batch of two scalar valued Normals.\n # Both have mean 1, but different standard deviations.\n dist = tfd.Normal(loc=1., scale=[11, 22.])\n\n # Evaluate the pdf of both distributions on the same point, 3.0,\n # returning a length 2 tensor.\n dist.prob(3.0)\n ```\n\n ", "desc": "The Normal distribution with location `loc` and `scale` parameters.", "type": "API"}, {"name": "tf.compat.v1.distributions.RegisterKL", "docs": "Decorator to register a KL divergence implementation function.\n\n Usage:\n\n @distributions.RegisterKL(distributions.Normal, distributions.Normal)\n def _kl_normal_mvn(norm_a, norm_b):\n # Return KL(norm_a || norm_b)\n ", "desc": "Decorator to register a KL divergence implementation function.", "type": "API"}, {"name": "tf.compat.v1.distributions.ReparameterizationType", "docs": "Instances of this class represent how sampling is reparameterized.\n\n Two static instances exist in the distributions library, signifying\n one of two possible properties for samples from a distribution:\n\n `FULLY_REPARAMETERIZED`: Samples from the distribution are fully\n reparameterized, and straight-through gradients are supported.\n\n `NOT_REPARAMETERIZED`: Samples from the distribution are not fully\n reparameterized, and straight-through gradients are either partially\n unsupported or are not supported at all. In this case, for purposes of\n e.g. RL or variational inference, it is generally safest to wrap the\n sample results in a `stop_gradients` call and use policy\n gradients / surrogate loss instead.\n ", "desc": "Instances of this class represent how sampling is reparameterized.", "type": "API"}, {"name": "tf.compat.v1.distributions.StudentT", "docs": "Student's t-distribution.\n\n This distribution has parameters: degree of freedom `df`, location `loc`,\n and `scale`.\n\n #### Mathematical details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; df, mu, sigma) = (1 + y**2 / df)**(-0.5 (df + 1)) / Z\n where,\n y = (x - mu) / sigma\n Z = abs(sigma) sqrt(df pi) Gamma(0.5 df) / Gamma(0.5 (df + 1))\n ```\n\n where:\n * `loc = mu`,\n * `scale = sigma`, and,\n * `Z` is the normalization constant, and,\n * `Gamma` is the [gamma function](\n https://en.wikipedia.org/wiki/Gamma_function).\n\n The StudentT distribution is a member of the [location-scale family](\n https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be\n constructed as,\n\n ```none\n X ~ StudentT(df, loc=0, scale=1)\n Y = loc + scale * X\n ```\n\n Notice that `scale` has semantics more similar to standard deviation than\n variance. However it is not actually the std. deviation; the Student's\n t-distribution std. dev. is `scale sqrt(df / (df - 2))` when `df > 2`.\n\n Samples of this distribution are reparameterized (pathwise differentiable).\n The derivatives are computed using the approach described in\n (Figurnov et al., 2018).\n\n #### Examples\n\n Examples of initialization of one or a batch of distributions.\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n # Define a single scalar Student t distribution.\n single_dist = tfd.StudentT(df=3)\n\n # Evaluate the pdf at 1, returning a scalar Tensor.\n single_dist.prob(1.)\n\n # Define a batch of two scalar valued Student t's.\n # The first has degrees of freedom 2, mean 1, and scale 11.\n # The second 3, 2 and 22.\n multi_dist = tfd.StudentT(df=[2, 3], loc=[1, 2.], scale=[11, 22.])\n\n # Evaluate the pdf of the first distribution on 0, and the second on 1.5,\n # returning a length two tensor.\n multi_dist.prob([0, 1.5])\n\n # Get 3 samples, returning a 3 x 2 tensor.\n multi_dist.sample(3)\n ```\n\n Arguments are broadcast when possible.\n\n ```python\n # Define a batch of two Student's t distributions.\n # Both have df 2 and mean 1, but different scales.\n dist = tfd.StudentT(df=2, loc=1, scale=[11, 22.])\n\n # Evaluate the pdf of both distributions on the same point, 3.0,\n # returning a length 2 tensor.\n dist.prob(3.0)\n ```\n\n Compute the gradients of samples w.r.t. the parameters:\n\n ```python\n df = tf.constant(2.0)\n loc = tf.constant(2.0)\n scale = tf.constant(11.0)\n dist = tfd.StudentT(df=df, loc=loc, scale=scale)\n samples = dist.sample(5) # Shape [5]\n loss = tf.reduce_mean(tf.square(samples)) # Arbitrary loss function\n # Unbiased stochastic gradients of the loss function\n grads = tf.gradients(loss, [df, loc, scale])\n ```\n\n References:\n Implicit Reparameterization Gradients:\n [Figurnov et al., 2018]\n (http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients)\n ([pdf](http://papers.nips.cc/paper/7326-implicit-reparameterization-gradients.pdf))\n ", "desc": "Student's t-distribution.", "type": "API"}, {"name": "tf.compat.v1.distributions.Uniform", "docs": "Uniform distribution with `low` and `high` parameters.\n\n #### Mathematical Details\n\n The probability density function (pdf) is,\n\n ```none\n pdf(x; a, b) = I[a <= x < b] / Z\n Z = b - a\n ```\n\n where\n\n - `low = a`,\n - `high = b`,\n - `Z` is the normalizing constant, and\n - `I[predicate]` is the [indicator function](\n https://en.wikipedia.org/wiki/Indicator_function) for `predicate`.\n\n The parameters `low` and `high` must be shaped in a way that supports\n broadcasting (e.g., `high - low` is a valid operation).\n\n #### Examples\n\n ```python\n # Without broadcasting:\n u1 = Uniform(low=3.0, high=4.0) # a single uniform distribution [3, 4]\n u2 = Uniform(low=[1.0, 2.0],\n high=[3.0, 4.0]) # 2 distributions [1, 3], [2, 4]\n u3 = Uniform(low=[[1.0, 2.0],\n [3.0, 4.0]],\n high=[[1.5, 2.5],\n [3.5, 4.5]]) # 4 distributions\n ```\n\n ```python\n # With broadcasting:\n u1 = Uniform(low=3.0, high=[5.0, 6.0, 7.0]) # 3 distributions\n ```\n\n ", "desc": "Uniform distribution with `low` and `high` parameters.", "type": "API"}, {"name": "tf.compat.v1.div", "docs": "Divides x / y elementwise (using Python 2 division operator semantics). (deprecated)\n\nDeprecated: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\nInstructions for updating:\nDeprecated in favor of operator or tf.math.divide.\n\n@compatibility(TF2)\nThis function is deprecated in TF2. Prefer using the Tensor division operator,\n`tf.divide`, or `tf.math.divide`, which obey the Python 3 division operator\nsemantics.\n@end_compatibility\n\n\nThis function divides `x` and `y`, forcing Python 2 semantics. That is, if `x`\nand `y` are both integers then the result will be an integer. This is in\ncontrast to Python 3, where division with `/` is always a float while division\nwith `//` is always an integer.\n\nArgs:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\nReturns:\n `x / y` returns the quotient of x and y.", "desc": "Divides x / y elementwise (using Python 2 division operator semantics). (deprecated)", "type": "API"}, {"name": "tf.compat.v1.div_no_nan", "docs": "Computes a safe divide which returns 0 if `y` (denominator) is zero.\n\n For example:\n\n >>> tf.constant(3.0) / 0.0\n \n >>> tf.math.divide_no_nan(3.0, 0.0)\n \n\n Note that 0 is returned if `y` is 0 even if `x` is nonfinite:\n\n >>> tf.math.divide_no_nan(np.nan, 0.0)\n \n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n\n Returns:\n The element-wise value of the x divided by y.\n ", "desc": "Computes a safe divide which returns 0 if `y` (denominator) is zero.", "type": "API"}, {"name": "tf.compat.v1.divide", "docs": "Computes Python style division of `x` by `y`.\n\n For example:\n\n >>> x = tf.constant([16, 12, 11])\n >>> y = tf.constant([4, 6, 2])\n >>> tf.divide(x,y)\n \n\n Args:\n x: A `Tensor`\n y: A `Tensor`\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with same shape as input\n ", "desc": "Computes Python style division of `x` by `y`.", "type": "API"}, {"name": "tf.compat.v1.DType", "docs": "Represents the type of the elements in a `Tensor`.\n\n `DType`'s are used to specify the output data type for operations which\n require it, or to inspect the data type of existing `Tensor`'s.\n\n Examples:\n\n >>> tf.constant(1, dtype=tf.int64)\n \n >>> tf.constant(1.0).dtype\n tf.float32\n\n See `tf.dtypes` for a complete list of `DType`'s defined.\n ", "desc": "Represents the type of the elements in a `Tensor`.", "type": "API"}, {"name": "tf.compat.v1.dtypes", "docs": "Public API for tf.dtypes namespace.\n", "desc": "Public API for tf.dtypes namespace.", "type": "API"}, {"name": "tf.compat.v1.dtypes.as_dtype", "docs": "Converts the given `type_value` to a `DType`.\n\n Note: `DType` values are interned. When passed a new `DType` object,\n `as_dtype` always returns the interned value.\n\n Args:\n type_value: A value that can be converted to a `tf.DType` object. This may\n currently be a `tf.DType` object, a [`DataType`\n enum](https://www.tensorflow.org/code/tensorflow/core/framework/types.proto),\n a string type name, or a [`numpy.dtype`](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html).\n\n Returns:\n A `DType` corresponding to `type_value`.\n\n Raises:\n TypeError: If `type_value` cannot be converted to a `DType`.\n ", "desc": "Converts the given `type_value` to a `DType`.", "type": "API"}, {"name": "tf.compat.v1.dtypes.as_string", "docs": "Converts each entry in the given tensor to strings.\n\n Supports many numeric types and boolean.\n\n For Unicode, see the\n [https://www.tensorflow.org/tutorials/representation/unicode](Working with Unicode text)\n tutorial.\n\n Examples:\n\n >>> tf.strings.as_string([3, 2])\n \n >>> tf.strings.as_string([3.1415926, 2.71828], precision=2).numpy()\n array([b'3.14', b'2.72'], dtype=object)\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `complex64`, `complex128`, `bool`, `variant`.\n precision: An optional `int`. Defaults to `-1`.\n The post-decimal precision to use for floating point numbers.\n Only used if precision > -1.\n scientific: An optional `bool`. Defaults to `False`.\n Use scientific notation for floating point numbers.\n shortest: An optional `bool`. Defaults to `False`.\n Use shortest representation (either scientific or standard) for\n floating point numbers.\n width: An optional `int`. Defaults to `-1`.\n Pad pre-decimal numbers to this width.\n Applies to both floating point and integer numbers.\n Only used if width > -1.\n fill: An optional `string`. Defaults to `\"\"`.\n The value to pad if width > -1. If empty, pads with spaces.\n Another typical value is '0'. String cannot be longer than 1 character.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n ", "desc": "Converts each entry in the given tensor to strings.", "type": "API"}, {"name": "tf.compat.v1.dtypes.cast", "docs": "Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.cast(x, tf.int32)\n \n\n Notice `tf.cast` has an alias `tf.dtypes.cast`:\n\n >>> x = tf.constant([1.8, 2.2], dtype=tf.float32)\n >>> tf.dtypes.cast(x, tf.int32)\n \n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Note casting nan and inf values to integral types has undefined behavior.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n ", "desc": "Casts a tensor to a new type.", "type": "API"}, {"name": "tf.compat.v1.dtypes.complex", "docs": "Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n\n Raises:\n TypeError: Real and imag must be correct types\n ", "desc": "Converts two real numbers to a complex number.", "type": "API"}, {"name": "tf.compat.v1.dtypes.DType", "docs": "Represents the type of the elements in a `Tensor`.\n\n `DType`'s are used to specify the output data type for operations which\n require it, or to inspect the data type of existing `Tensor`'s.\n\n Examples:\n\n >>> tf.constant(1, dtype=tf.int64)\n \n >>> tf.constant(1.0).dtype\n tf.float32\n\n See `tf.dtypes` for a complete list of `DType`'s defined.\n ", "desc": "Represents the type of the elements in a `Tensor`.", "type": "API"}, {"name": "tf.compat.v1.dtypes.saturate_cast", "docs": "Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n ", "desc": "Performs a safe saturating cast of `value` to `dtype`.", "type": "API"}, {"name": "tf.compat.v1.dynamic_partition", "docs": "Partitions `data` into `num_partitions` tensors using indices from `partitions`.\n\n For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`\n becomes part of `outputs[partitions[js]]`. The slices with `partitions[js] = i`\n are placed in `outputs[i]` in lexicographic order of `js`, and the first\n dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.\n In detail,\n\n ```python\n outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]\n\n outputs[i] = pack([data[js, ...] for js if partitions[js] == i])\n ```\n\n `data.shape` must start with `partitions.shape`.\n\n For example:\n\n ```python\n # Scalar partitions.\n partitions = 1\n num_partitions = 2\n data = [10, 20]\n outputs[0] = [] # Empty with shape [0, 2]\n outputs[1] = [[10, 20]]\n\n # Vector partitions.\n partitions = [0, 0, 1, 1, 0]\n num_partitions = 2\n data = [10, 20, 30, 40, 50]\n outputs[0] = [10, 20, 50]\n outputs[1] = [30, 40]\n ```\n\n See `dynamic_stitch` for an example on how to merge partitions back.\n\n \n
![](\"https://www.tensorflow.org/images/DynamicPartition.png\")
\n
\n
![](\"https://www.tensorflow.org/images/DynamicStitch.png\")
\n
\n
![](\"https://www.tensorflow.org/images/Gather.png\"\nalt)
\n