Add files using upload-large-folder tool

.gitattributes

@@ -870,3 +870,5 @@ videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/image_
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_sparse_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/array_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_image_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_experimental_dataset_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_tpu_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/backprop.py

@@ -0,0 +1,1345 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Code for backpropagation using the tape utilities."""
+
+# TODO(b/159343581): Properly support CompositeTensor in all functions in this
+# file.
+
+import functools
+import operator
+
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.eager import backprop_util
+from tensorflow.python.eager import context
+from tensorflow.python.eager import execute
+from tensorflow.python.eager import imperative_grad
+from tensorflow.python.eager import tape
+from tensorflow.python.framework import composite_tensor
+from tensorflow.python.framework import composite_tensor_gradient
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import indexed_slices
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor as tensor_lib
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.framework import type_spec
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import check_ops
+from tensorflow.python.ops import control_flow_util
+from tensorflow.python.ops import default_gradient
+from tensorflow.python.ops import gen_array_ops
+from tensorflow.python.ops import gen_math_ops
+from tensorflow.python.ops import gradients_impl  # pylint: disable=unused-import
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.ops.parallel_for import control_flow_ops as pfor_ops
+from tensorflow.python.ops.unconnected_gradients import UnconnectedGradients
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util import _pywrap_utils
+from tensorflow.python.util import nest
+from tensorflow.python.util import tf_contextlib
+from tensorflow.python.util import tf_inspect
+from tensorflow.python.util import variable_utils
+from tensorflow.python.util.tf_export import tf_export
+
+
+_op_attr_type_cache = {}
+
+
+def op_attr_type(op_type, attr_name):
+  try:
+    return _op_attr_type_cache[(op_type, attr_name)]
+  except KeyError:
+    context.ensure_initialized()
+    h = context.context()._handle  # pylint: disable=protected-access
+    attr_type = pywrap_tfe.TFE_OpNameGetAttrType(h, op_type, attr_name)
+  _op_attr_type_cache[(op_type, attr_name)] = attr_type
+  return attr_type
+
+
+def make_attr(attr_type, value):
+  # pybind11 enums do not return the raw value like SWIG enums do. They are
+  # useful when comparing amongst each other but not direct integers as we are
+  # doing in most tests.
+  # https://pybind11.readthedocs.io/en/stable/classes.html#enumerations-and-internal-types
+  # TODO(amitpatankar): After all SWIG transitions, convert the enum comparisons
+  # from integer value to class.
+  if attr_type == int(pywrap_tfe.TF_ATTR_TYPE):
+    return dtypes.as_dtype(value)
+  if attr_type == [int(pywrap_tfe.TF_ATTR_TYPE)]:
+    return [dtypes.as_dtype(v) for v in value]
+  if attr_type == int(pywrap_tfe.TF_ATTR_SHAPE):
+    return tensor_shape.as_shape(value).as_proto()
+  if attr_type == [int(pywrap_tfe.TF_ATTR_SHAPE)]:
+    return [tensor_shape.as_shape(v).as_proto() for v in value]
+  return nest.map_structure(
+      lambda v: v.encode() if isinstance(v, str) else v,
+      value)
+
+
+class _MockOp(object):
+  """Pretends to be a tf.Operation for the gradient functions."""
+
+  def __init__(self, attrs, inputs, outputs, typ, skip_input_indices):
+    self.attrs = attrs
+    self.inputs = inputs
+    self.outputs = outputs
+    self.type = typ
+    self.skip_input_indices = skip_input_indices
+
+  def get_attr(self, attr):
+    typ = op_attr_type(self.type, attr)
+    for i in range(0, len(self.attrs), 2):
+      if self.attrs[i] == attr:
+        return make_attr(typ, self.attrs[i + 1])
+    raise KeyError(attr)
+
+  def _get_control_flow_context(self):
+    raise NotImplementedError(
+        "tf.GradientTape.gradients() does not support graph control flow "
+        "operations like tf.cond or tf.while at this time. Use tf.gradients() "
+        "instead. If you need this feature, please file a feature request at "
+        "https://github.com/tensorflow/tensorflow/issues/new"
+    )
+
+
+def _gradient_function(op_name, attr_tuple, num_inputs, inputs, outputs,
+                       out_grads, skip_input_indices, forward_pass_name_scope):
+  """Calls the gradient function of the op.
+
+  Args:
+    op_name: the name of the op to be differentiated.
+    attr_tuple: the attrs, as a tuple.
+    num_inputs: the number of inputs to the op.
+    inputs: inputs to the original operation.
+    outputs: outputs to the original operation.
+    out_grads: gradients of the operation wrt its outputs.
+    skip_input_indices: a tuple that is passed to the gradient function,
+      indicating which inputs to skip calculating the gradient for
+    forward_pass_name_scope: the namescope of the op in the forward pass.
+
+  Returns:
+    The gradients with respect to the inputs of the function, as a list.
+  """
+  mock_op = _MockOp(attr_tuple, inputs, outputs, op_name, skip_input_indices)
+  grad_fn = ops._gradient_registry.lookup(op_name)  # pylint: disable=protected-access
+  if grad_fn is None:
+    return [None] * num_inputs
+
+  # This does not work with v1 TensorArrays.
+  if ops.executing_eagerly_outside_functions(
+  ) or control_flow_util.EnableControlFlowV2(ops.get_default_graph()):
+    gradient_name_scope = "gradient_tape/"
+    if forward_pass_name_scope:
+      gradient_name_scope += forward_pass_name_scope + "/"
+    with ops.name_scope(gradient_name_scope):
+      return grad_fn(mock_op, *out_grads)
+  else:
+    return grad_fn(mock_op, *out_grads)
+
+
+pywrap_tfe.TFE_Py_RegisterGradientFunction(_gradient_function)
+
+
+def _must_record_gradient():
+  return not pywrap_tfe.TFE_Py_TapeSetIsEmpty()
+
+
+@tf_export("__internal__.record_gradient", v1=[])
+def record_gradient(op_name, inputs, attrs, outputs):
+  """Explicitly record the gradient for a given op.
+
+  Args:
+    op_name: The op name as listed in the `OpDef` for the op.
+    inputs: A list of tensor inputs to the op.
+    attrs: The op attributes as a flattened list of alternating attribute names
+      and attribute values.
+    outputs: A list of tensor outputs from the op.
+  """
+  pywrap_tfe.TFE_Py_RecordGradient(op_name, inputs, attrs, outputs,
+                                   ops.get_name_scope())
+
+
+execute.must_record_gradient = _must_record_gradient
+execute.record_gradient = record_gradient
+
+
+def implicit_val_and_grad(f):
+  """Returns a function which differentiates f with respect to variables.
+
+  The wrapped function returns the value and the gradient of f when called with
+  the same arguments. The gradient is with respect to all trainable TFE
+  variables accessed by `f`.
+
+  This function is useful when the exact set of variables to differentiate with
+  is not known ahead of time.
+
+  Example:
+
+  ```python
+  dense_layer = tf.compat.v1.layers.Dense(1)
+  def loss(x, y):
+    return tf.reduce_sum(tf.square(dense_layer(x) - y))
+
+  # Obtain the gradient function.
+  val_grad_fn = tfe.implicit_value_and_gradients(loss)
+
+  # Invoke the gradient function with concrete values of x and y.
+  x = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+  y = tf.constant([[10.0], [20.0]])
+  value, grads_and_vars = val_grad_fn(x, y)
+  print('Value of loss: %s' % value)
+
+  # Apply the gradients to Variables.
+  optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1)
+  optimizer.apply_gradients(grads_and_vars)
+  ```
+
+  Args:
+    f: function to be differentiated. If `f` returns a scalar, this scalar will
+      be differentiated. If `f` returns a tensor or list of tensors, by default
+      a scalar will be computed by adding all their values to produce a single
+      scalar.
+
+  Returns:
+    A function which, when called, returns a tuple pair.
+    Its first element is the value to which the function evaluates.
+    Its second element is list of (gradient, variable) pairs.
+
+  Raises:
+    ValueError: if `f` returns None.
+  """
+  # TODO(cais): Remove calls to tf.constant() once the gradients functions
+  # accept lists and np.ndarrays.
+
+  def grad_fn(*args, **kwds):
+    """Computes the gradient of the wrapped function."""
+    this_tape = tape.push_new_tape()
+    try:
+      end_node = f(*args, **kwds)
+      if end_node is None:
+        raise ValueError("Cannot differentiate a function that returns None; "
+                         "did you forget to return a value from {}?".format(
+                             f.__name__))
+    finally:
+      tape.pop_tape(this_tape)
+    # Note: variables are returned in construction order. This ensures unique
+    # order across executions.
+    variables = this_tape.watched_variables()
+    if not variables:
+      raise ValueError("No trainable variables were accessed while the "
+                       "function was being computed.")
+
+    sources = [v.handle for v in variables]
+    for s in sources:
+      if getattr(s, "is_packed", False):
+        raise ValueError(
+            "GradientTape.gradient is not supported on packed EagerTensors yet."
+        )
+    grad = imperative_grad.imperative_grad(this_tape, nest.flatten(end_node),
+                                           sources)
+    return end_node, list(zip(grad, variables))
+
+  return grad_fn
+
+
+def implicit_grad(f):
+  """Returns a function which differentiates f with respect to variables.
+
+  The wrapped function returns the gradient of f when called with the same
+  arguments. The gradient is with respect to all trainable TFE variables
+  accessed by `f`.
+
+  This function is useful when the exact set of variables to differentiate with
+  is not known ahead of time.
+
+  Example:
+
+  ```python
+  dense_layer = tf.compat.v1.layers.Dense(1)
+  def loss(x, y):
+    return tf.reduce_sum(tf.square(dense_layer(x) - y))
+
+  # Obtain the gradient function.
+  grad_fn = tfe.implicit_gradients(loss)
+
+  # Invoke the gradient function with concrete values of x and y.
+  x = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+  y = tf.constant([[10.0], [20.0]])
+  grads_and_vars = grad_fn(x, y)
+
+  # Apply the gradients to Variables.
+  optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1)
+  optimizer.apply_gradients(grads_and_vars)
+  ```
+
+  Args:
+    f: function to be differentiated. If `f` returns a scalar, this scalar will
+      be differentiated. If `f` returns a tensor or list of tensors, by default
+      a scalar will be computed by adding all their values to produce a single
+      scalar.
+
+  Returns:
+    A function which, when called, returns a list of (gradient, variable) pairs.
+  """
+  # TODO(cais): Remove calls to tf.constant() once the gradients functions
+  # accept lists and np.ndarrays.
+
+  def grad_fn(*args, **kwds):
+    """Computes the gradient of the wrapped function."""
+    return implicit_val_and_grad(f)(*args, **kwds)[1]
+
+  return grad_fn
+
+
+def _get_arg_spec(f, params, param_args):
+  """The positions of the parameters of f to be differentiated in param_args."""
+  try:
+    args = tf_inspect.getfullargspec(f).args
+  except TypeError as e:
+    # TypeError can happen when f is a callable object.
+    if params is None:
+      return range(len(param_args))
+    elif all(isinstance(x, int) for x in params):
+      return params
+    raise ValueError("Either callable provided is not a function or could not "
+                     "inspect its arguments by name: %s. Original error: %s"
+                     % (f, e))
+  if params is None:
+    if not args:
+      return range(len(param_args))
+    if args[0] == "self":
+      return range(len(args) - 1)
+    else:
+      return range(len(args))
+  elif all(isinstance(x, str) for x in params):
+    return [args.index(n) for n in params]
+  elif all(isinstance(x, int) for x in params):
+    return params
+  else:
+    raise ValueError(
+        "params must be all strings or all integers; got %s." % params)
+
+
+def gradients_function(f, params=None):
+  """Returns a function which differentiates f with respect to params.
+
+  Example:
+  ```python
+  # f(x, y) = (x ^ 3) * y - x * (y ^ 2)
+  # Therefore, the 1st order derivatives are:
+  #   df / dx = 3 * (x ^ 2) * y - y ^ 2
+  #   df / dy = x ^ 3 - 2 * x * y
+  # The 2nd order derivatives with respect to x is:
+  #   d^2 f / (dx)^2 = 6 * x * y
+  def f(x, y):
+    return x * x * x * y - x * y * y
+
+  # Obtain a function that returns 1st order gradients.
+  grad_fn = tfe.gradients_function(f)
+
+  x = 2.0
+  y = 3.0
+
+  # Invoke the 1st order gradient function.
+  x_grad, y_grad = grad_fn(x, y)
+  assert x_grad.numpy() == 3 * (2 ** 2) * 3 - 3 ** 2
+  assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3
+
+  # Obtain a function that returns the 2nd order gradient with respect to x.
+  gradgrad_fn = tfe.gradients_function(lambda x, y: grad_fn(x, y)[0])
+
+  # Invoke the 2nd order gradient function.
+  x_gradgrad = gradgrad_fn(x, y)[0]
+  assert x_gradgrad.numpy() == 6 * 2 * 3
+
+  # To obtain a callable that returns the gradient(s) of `f` with respect to a
+  # subset of its inputs, use the `params` keyword argument with
+  # `gradients_function()`.
+  ygrad_fn = tfe.gradients_function(f, params=[1])
+
+  (y_grad,) = ygrad_fn(x, y)
+  assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3
+  ```
+
+  Note that only tensors with real or complex dtypes are differentiable.
+
+  Args:
+    f: function to be differentiated. If `f` returns a scalar, this scalar will
+      be differentiated. If `f` returns a tensor or list of tensors, by default
+      a scalar will be computed by adding all their values to produce a single
+      scalar. If desired, the tensors can be elementwise multiplied by the
+      tensors passed as the `dy` keyword argument to the returned gradient
+      function.
+    params: list of parameter names of f or list of integers indexing the
+      parameters with respect to which we'll differentiate. Passing None
+      differentiates with respect to all parameters.
+
+  Returns:
+    function which, when called, returns the value of f and the gradient
+    of `f` with respect to all of `params`. The function takes an extra optional
+    keyword argument `dy`. Setting it allows computation of vector jacobian
+    products for vectors other than the vector of ones.
+
+  Raises:
+    ValueError: if the params are not all strings or all integers.
+  """
+
+  def decorated(*args, **kwds):
+    """Computes the gradient of the decorated function."""
+
+    _, grad = val_and_grad_function(f, params=params)(*args, **kwds)
+    return grad
+
+  return decorated
+
+
+def _ensure_unique_tensor_objects(parameter_positions, args):
+  """Make each of the parameter_positions in args a unique tensor_lib.Tensor object.
+
+  Ensure that each parameter is treated independently.
+  For example:
+
+  def f(x, y): return x * y
+  g = gradients_function(f)
+  one = tf.constant(1.)
+
+  g(one, one) should return [1., 1.]
+  (even though the two arguments are the same Tensor object).
+
+  Args:
+    parameter_positions: List of indices into args defining the arguments to
+      differentiate against.
+    args: A list of arguments to the function to be differentiated.
+
+  Returns:
+    args, possibly edited in-place.
+  """
+  s = set()
+  for (i, t) in enumerate(args):
+    if i in parameter_positions:
+      tid = ops.tensor_id(t)
+      if tid in s:
+        args[i] = gen_array_ops.identity(args[i])
+      else:
+        s.add(tid)
+  return args
+
+
+def val_and_grad_function(f, params=None):
+  """Returns a function that computes f and its derivative w.r.t. params.
+
+  Example:
+  ```python
+  # f(x, y) = (x ^ 3) * y - x * (y ^ 2)
+  # Therefore, the 1st order derivatives are:
+  #   df / dx = 3 * (x ^ 2) * y - y ^ 2
+  #   df / dy = x ^ 3 - 2 * x * y
+  def f(x, y):
+    return x * x * x * y - x * y * y
+
+  # Obtain a function that returns the function value and the 1st order
+  # gradients.
+  val_grads_fn = tfe.value_and_gradients_function(f)
+
+  x = 2.0
+  y = 3.0
+
+  # Invoke the value-and-gradients function.
+  f_val, (x_grad, y_grad) = val_grads_fn(x, y)
+  assert f_val.numpy() == (2 ** 3) * 3 - 2 * (3 ** 2)
+  assert x_grad.numpy() == 3 * (2 ** 2) * 3 - 3 ** 2
+  assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3
+
+  # To obtain a callable that returns the value of `f` and the gradient(s) of
+  # `f` with respect to a subset of its inputs, use the `params` keyword
+  # argument with `value_and_gradients_function()`.
+  val_ygrad_fn = tfe.value_and_gradients_function(f, params=[1])
+
+  f_val, (y_grad,) = val_ygrad_fn(x, y)
+  assert f_val.numpy() == (2 ** 3) * 3 - 2 * (3 ** 2)
+  assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3
+  ```
+
+  Args:
+    f: function to be differentiated. If `f` returns a scalar, this scalar will
+      be differentiated. If `f` returns a tensor or list of tensors, by default
+      a scalar will be computed by adding all their values to produce a single
+      scalar. If desired, the tensors can be elementwise multiplied by the
+      tensors passed as the `dy` keyword argument to the returned gradient
+      function.
+    params: list of parameter names of f or list of integers indexing the
+      parameters with respect to which we'll differentiate. Passing `None`
+      differentiates with respect to all parameters.
+
+  Returns:
+    function which, when called, returns the value of f and the gradient
+    of f with respect to all of `params`. The function takes an extra optional
+    keyword argument "dy". Setting it allows computation of vector jacobian
+    products for vectors other than the vector of ones.
+
+  Raises:
+    ValueError: if the params are not all strings or all integers.
+  """
+
+  def decorated(*args, **kwds):
+    """Computes the value and gradient of the decorated function."""
+    dy = kwds.pop("dy", None)
+    if kwds:
+      raise ValueError("Functions to be differentiated cannot "
+                       "receive keyword arguments.")
+    val, vjp = make_vjp(f, params)(*args, **kwds)
+    return val, vjp(dy=dy)
+
+  return decorated
+
+
+def make_vjp(f, params=None, persistent=True):
+  """Returns a function that computes f and its vjp w.r.t.
+
+  params.
+
+  The term "vjp" here is an abbreviation for vector-jacobian product.
+
+  Args:
+    f: the function to be differentiated.
+    params: the parameters (numbers or names) to differentiate with respect to.
+      A value of None will differentiate with respect to all parameters.
+    persistent: Boolean controlling whether the VJP function can be re-used.
+      Must be True or False.
+
+  Returns:
+    A function, which when called, returns a tuple (value, vjp), where:
+    - value is the result of calling f.
+    - vjp is a function, which takes a vector as an argument and
+      returns the product of that vector with the Jacobian of f.
+      Providing no argument to vjp is equivalent to providing a
+      vector of ones.
+
+    For example,
+    ```python
+    def f(x):
+      return x * x
+
+    wrapped_fn = tfe.make_vjp(f)
+    result, vjp = wrapped_fn(tf.constant(3.0))
+    # result is 9.0
+    vjp()  # the vjp function returns 6.0
+
+  Raises:
+    ValueError: if `f` returns None.
+  """
+
+  def decorated(*args, **kwds):
+    """Computes the value and gradient of the decorated function."""
+    parameter_positions = _get_arg_spec(f, params, args)
+    assert not kwds, "The gradient function can't take keyword arguments."
+    this_tape = tape.push_new_tape(persistent=persistent)
+    try:
+      sources = []
+      args = [
+          ops.convert_to_tensor(arg) if i in parameter_positions else arg
+          for i, arg in enumerate(args)
+      ]
+      args = _ensure_unique_tensor_objects(parameter_positions, args)
+      for i in parameter_positions:
+        if getattr(args[i], "is_packed", False):
+          raise ValueError(
+              "GradientTape.gradient is not supported on packed EagerTensors"
+              "yet.")
+        sources.append(args[i])
+        tape.watch(this_tape, args[i])
+      result = f(*args)
+      if result is None:
+        raise ValueError("Cannot differentiate a function that returns None; "
+                         "did you forget to return a value from {}?".format(
+                             f.__name__))
+      flat_result = nest.flatten(result)
+      flat_result = [gen_array_ops.identity(x) for x in flat_result]
+      result = nest.pack_sequence_as(result, flat_result)
+    finally:
+      tape.pop_tape(this_tape)
+    def vjp(dy=None):
+      if dy is not None:
+        dy = [ops.convert_to_tensor(x) for x in nest.flatten(dy)]
+      return imperative_grad.imperative_grad(
+          this_tape, nest.flatten(result), sources, output_gradients=dy)
+
+    return result, vjp
+
+  return decorated
+
+
+def _aggregate_grads(gradients):
+  """Aggregate gradients from multiple sources.
+
+  Args:
+    gradients: A list of 'Tensor' or 'IndexedSlices' gradients.
+
+  Returns:
+    If 'gradients' only has 'Tensor', returns an aggregated 'Tensor'.
+    Otherwise returns an aggregated 'IndexedSlices'.
+  """
+  assert gradients, "No gradients to aggregate"
+
+  if len(gradients) == 1:
+    return gradients[0]
+  if all(isinstance(g, tensor_lib.Tensor) for g in gradients):
+    return gen_math_ops.add_n(gradients)
+  else:
+    assert all(
+        isinstance(g, (tensor_lib.Tensor, indexed_slices.IndexedSlices))
+        for g in gradients)
+    return backprop_util.AggregateIndexedSlicesGradients(gradients)
+
+
+def _num_elements(grad):
+  """The number of elements in the `grad` tensor."""
+  if isinstance(grad, tensor_lib.Tensor):
+    shape_tuple = grad._shape_tuple()  # pylint: disable=protected-access
+  elif isinstance(grad, indexed_slices.IndexedSlices):
+    shape_tuple = grad.values._shape_tuple()  # pylint: disable=protected-access
+  else:
+    raise ValueError("`grad` not a Tensor or IndexedSlices.")
+  if shape_tuple is None or None in shape_tuple:
+    return 0
+  return functools.reduce(operator.mul, shape_tuple, 1)
+
+
+def _fast_fill(value, shape, dtype):
+  return array_ops.fill(
+      constant_op.constant(shape, dtype=dtypes.int32),
+      constant_op.constant(value, dtype=dtype))
+
+
+def _zeros(shape, dtype):
+  """Helper to return (possibly cached) zero tensors in eager mode."""
+  # Note: variants will use _zeros_like
+  if dtype == dtypes.string or dtype == dtypes.resource:
+    return None
+
+  ctx = context.context()
+  if not ctx.executing_eagerly():
+    return array_ops.zeros(shape, dtype)
+
+  device = ctx.device_name
+
+  if tensor_util.is_tf_type(shape):
+    shape_key = shape.ref()
+  else:
+    shape_key = shape
+  cache_key = shape_key, dtype, device
+  cached = ctx.zeros_cache().get(cache_key)
+  if cached is None:
+    if dtypes.as_dtype(dtype).is_bool:
+      value = False
+    else:
+      value = 0
+    cached = _fast_fill(value, shape, dtype)
+    ctx.zeros_cache().put(cache_key, cached)
+  return cached
+
+
+def _ones(shape, dtype):
+  as_dtype = dtypes.as_dtype(dtype)
+  if as_dtype == dtypes.string:
+    return None
+
+  if not context.executing_eagerly():
+    return array_ops.ones(shape, dtype)
+
+  if as_dtype.is_bool:
+    value = True
+  else:
+    value = 1
+
+  if shape == ():  # pylint: disable=g-explicit-bool-comparison
+    return constant_op.constant(value, dtype=dtype)
+  return _fast_fill(value, shape, dtype)
+
+
+_default_vspace = imperative_grad.VSpace(
+    num_elements_fn=_num_elements,
+    aggregate_fn=_aggregate_grads,
+    zeros_fn=_zeros,
+    ones_fn=_ones,
+    zeros_like_fn=default_gradient.zeros_like,
+    ones_like_fn=default_gradient.ones_like,
+    graph_shape_fn=gen_array_ops.shape)
+pywrap_tfe.TFE_Py_RegisterVSpace(_default_vspace)
+
+
+def _handle_or_self(x):
+  """Unwrap resource variable/ndarray to return tensors."""
+  if resource_variable_ops.is_resource_variable(x):
+    return x.handle
+  return x
+
+
+def _extract_tensors_and_variables(tensor):
+  """Extracts tensors and variables from the input object."""
+  for obj in nest.flatten(tensor):
+    if _pywrap_utils.IsTensor(obj) or _pywrap_utils.IsVariable(obj):
+      yield obj
+    elif isinstance(obj, composite_tensor.CompositeTensor):
+      components = type_spec.type_spec_from_value(obj)._to_components(obj)  # pylint: disable=protected-access
+      yield from _extract_tensors_and_variables(components)
+    else:
+      raise ValueError(f"Passed in object {obj} of type {type(obj).__name__!r}"
+                       f", not tf.Tensor or tf.Variable or ExtensionType.")
+
+
+@tf_export("GradientTape", "autodiff.GradientTape", v1=["GradientTape"])
+class GradientTape:
+  """Record operations for automatic differentiation.
+
+  Operations are recorded if they are executed within this context manager and
+  at least one of their inputs is being "watched".
+
+  Trainable variables (created by `tf.Variable` or `tf.compat.v1.get_variable`,
+  where `trainable=True` is default in both cases) are automatically watched.
+  Tensors can be manually watched by invoking the `watch` method on this context
+  manager.
+
+  For example, consider the function `y = x * x`. The gradient at `x = 3.0` can
+  be computed as:
+
+  >>> x = tf.constant(3.0)
+  >>> with tf.GradientTape() as g:
+  ...   g.watch(x)
+  ...   y = x * x
+  >>> dy_dx = g.gradient(y, x)
+  >>> print(dy_dx)
+  tf.Tensor(6.0, shape=(), dtype=float32)
+
+  GradientTapes can be nested to compute higher-order derivatives. For example,
+
+  >>> x = tf.constant(5.0)
+  >>> with tf.GradientTape() as g:
+  ...   g.watch(x)
+  ...   with tf.GradientTape() as gg:
+  ...     gg.watch(x)
+  ...     y = x * x
+  ...   dy_dx = gg.gradient(y, x)  # dy_dx = 2 * x
+  >>> d2y_dx2 = g.gradient(dy_dx, x)  # d2y_dx2 = 2
+  >>> print(dy_dx)
+  tf.Tensor(10.0, shape=(), dtype=float32)
+  >>> print(d2y_dx2)
+  tf.Tensor(2.0, shape=(), dtype=float32)
+
+  By default, the resources held by a GradientTape are released as soon as
+  GradientTape.gradient() method is called. To compute multiple gradients over
+  the same computation, create a persistent gradient tape. This allows multiple
+  calls to the gradient() method as resources are released when the tape object
+  is garbage collected. For example:
+
+  >>> x = tf.constant(3.0)
+  >>> with tf.GradientTape(persistent=True) as g:
+  ...   g.watch(x)
+  ...   y = x * x
+  ...   z = y * y
+  >>> dz_dx = g.gradient(z, x)  # (4*x^3 at x = 3)
+  >>> print(dz_dx)
+  tf.Tensor(108.0, shape=(), dtype=float32)
+  >>> dy_dx = g.gradient(y, x)
+  >>> print(dy_dx)
+  tf.Tensor(6.0, shape=(), dtype=float32)
+
+  By default GradientTape will automatically watch any trainable variables that
+  are accessed inside the context. If you want fine grained control over which
+  variables are watched you can disable automatic tracking by passing
+  `watch_accessed_variables=False` to the tape constructor:
+
+  >>> x = tf.Variable(2.0)
+  >>> w = tf.Variable(5.0)
+  >>> with tf.GradientTape(
+  ...     watch_accessed_variables=False, persistent=True) as tape:
+  ...   tape.watch(x)
+  ...   y = x ** 2  # Gradients will be available for `x`.
+  ...   z = w ** 3  # No gradients will be available as `w` isn't being watched.
+  >>> dy_dx = tape.gradient(y, x)
+  >>> print(dy_dx)
+  tf.Tensor(4.0, shape=(), dtype=float32)
+  >>> # No gradients will be available as `w` isn't being watched.
+  >>> dz_dw = tape.gradient(z, w)
+  >>> print(dz_dw)
+  None
+
+  Note that when using models you should ensure that your variables exist when
+  using `watch_accessed_variables=False`. Otherwise it's quite easy to make your
+  first iteration not have any gradients:
+
+  ```python
+  a = tf.keras.layers.Dense(32)
+  b = tf.keras.layers.Dense(32)
+
+  with tf.GradientTape(watch_accessed_variables=False) as tape:
+    tape.watch(a.variables)  # Since `a.build` has not been called at this point
+                             # `a.variables` will return an empty list and the
+                             # tape will not be watching anything.
+    result = b(a(inputs))
+    tape.gradient(result, a.variables)  # The result of this computation will be
+                                        # a list of `None`s since a's variables
+                                        # are not being watched.
+  ```
+
+  Note that only tensors with real or complex dtypes are differentiable.
+  """
+
+  def __init__(self, persistent=False, watch_accessed_variables=True):
+    """Creates a new GradientTape.
+
+    Args:
+      persistent: Boolean controlling whether a persistent gradient tape
+        is created. False by default, which means at most one call can
+        be made to the gradient() method on this object.
+      watch_accessed_variables: Boolean controlling whether the tape will
+        automatically `watch` any (trainable) variables accessed while the tape
+        is active. Defaults to True meaning gradients can be requested from any
+        result computed in the tape derived from reading a trainable `Variable`.
+        If False users must explicitly `watch` any `Variable`s they want to
+        request gradients from.
+    """
+    self._tape = None
+    self._persistent = persistent
+    self._watch_accessed_variables = watch_accessed_variables
+    self._watched_variables = ()
+    self._recording = False
+
+  def __enter__(self):
+    """Enters a context inside which operations are recorded on this tape."""
+    self._push_tape()
+    return self
+
+  def __exit__(self, typ, value, traceback):
+    """Exits the recording context, no further operations are traced."""
+    if self._recording:
+      self._pop_tape()
+
+  def _push_tape(self):
+    """Pushes a new tape onto the tape stack."""
+    if self._recording:
+      raise ValueError("Tape is still recording, This can happen if you try to "
+                       "re-enter an already-active tape.")
+    if self._tape is None:
+      self._tape = tape.push_new_tape(
+          persistent=self._persistent,
+          watch_accessed_variables=self._watch_accessed_variables)
+    else:
+      tape.push_tape(self._tape)
+    self._recording = True
+
+  def _pop_tape(self):
+    if not self._recording:
+      raise ValueError("Tape is not recording.")
+    tape.pop_tape(self._tape)
+    self._recording = False
+
+  @tf_contextlib.contextmanager
+  def _ensure_recording(self):
+    """Ensures that this tape is recording."""
+    if not self._recording:
+      try:
+        self._push_tape()
+        yield
+      finally:
+        self._pop_tape()
+    else:
+      yield
+
+  # TODO(b/209081027): Add a variable in composite tensor test case after
+  # variables become composite tensors.
+  def watch(self, tensor):
+    """Ensures that `tensor` is being traced by this tape.
+
+    Args:
+      tensor: a Tensor/Variable or list of Tensors/Variables.
+
+    Raises:
+      ValueError: if it encounters something that is not a tensor.
+    """
+    for t in _extract_tensors_and_variables(tensor):
+      if not backprop_util.IsTrainable(t):
+        logging.log_first_n(
+            logging.WARN, "The dtype of the watched tensor must be "
+            "floating (e.g. tf.float32), got %r", 5, t.dtype)
+      if hasattr(t, "handle"):
+        # There are many variable-like objects, all of them currently have
+        # `handle` attribute that points to a tensor. If this changes,
+        # internals of watch_variable need to change as well.
+        tape.watch_variable(self._tape, t)
+      else:
+        tape.watch(self._tape, t)
+
+  @tf_contextlib.contextmanager
+  def stop_recording(self):
+    """Temporarily stops recording operations on this tape.
+
+    Operations executed while this context manager is active will not be
+    recorded on the tape. This is useful for reducing the memory used by tracing
+    all computations.
+
+    For example:
+
+    >>> x = tf.constant(4.0)
+    >>> with tf.GradientTape() as tape:
+    ...   with tape.stop_recording():
+    ...     y = x ** 2
+    >>> dy_dx = tape.gradient(y, x)
+    >>> print(dy_dx)
+    None
+
+    Yields:
+      None
+    Raises:
+      RuntimeError: if the tape is not currently recording.
+    """
+    if self._tape is None:
+      raise RuntimeError(
+          "Trying to stop recording a tape which is not recording.")
+    self._pop_tape()
+    try:
+      yield
+    finally:
+      self._push_tape()
+
+  def reset(self):
+    """Clears all information stored in this tape.
+
+    Equivalent to exiting and reentering the tape context manager with a new
+    tape. For example, the two following code blocks are equivalent:
+
+    ```
+    with tf.GradientTape() as t:
+      loss = loss_fn()
+    with tf.GradientTape() as t:
+      loss += other_loss_fn()
+    t.gradient(loss, ...)  # Only differentiates other_loss_fn, not loss_fn
+
+
+    # The following is equivalent to the above
+    with tf.GradientTape() as t:
+      loss = loss_fn()
+      t.reset()
+      loss += other_loss_fn()
+    t.gradient(loss, ...)  # Only differentiates other_loss_fn, not loss_fn
+    ```
+
+    This is useful if you don't want to exit the context manager for the tape,
+    or can't because the desired reset point is inside a control flow construct:
+
+    ```
+    with tf.GradientTape() as t:
+      loss = ...
+      if loss > k:
+        t.reset()
+    ```
+    """
+    self._pop_tape()
+    self._tape = None
+    self._push_tape()
+
+  def watched_variables(self):
+    """Returns variables watched by this tape in order of construction."""
+    if self._tape is not None:
+      self._watched_variables = self._tape.watched_variables()
+    return self._watched_variables
+
+  def gradient(self,
+               target,
+               sources,
+               output_gradients=None,
+               unconnected_gradients=UnconnectedGradients.NONE):
+    """Computes the gradient using operations recorded in context of this tape.
+
+    Note: Unless you set `persistent=True` a GradientTape can only be used to
+    compute one set of gradients (or jacobians).
+
+    In addition to Tensors, gradient also supports RaggedTensors. For example,
+
+    >>> x = tf.ragged.constant([[1.0, 2.0], [3.0]])
+    >>> with tf.GradientTape() as g:
+    ...   g.watch(x)
+    ...   y = x * x
+    >>> g.gradient(y, x)
+    <tf.RaggedTensor [[2.0, 4.0], [6.0]]>
+
+    Args:
+      target: a list or nested structure of Tensors or Variables or
+        CompositeTensors to be differentiated.
+      sources: a list or nested structure of Tensors or Variables or
+        CompositeTensors. `target` will be differentiated against elements in
+        `sources`.
+      output_gradients: a list of gradients, one for each differentiable
+        element of target. Defaults to None.
+      unconnected_gradients: a value which can either hold 'none' or 'zero' and
+        alters the value which will be returned if the target and sources are
+        unconnected. The possible values and effects are detailed in
+        'UnconnectedGradients' and it defaults to 'none'.
+
+    Returns:
+      a list or nested structure of Tensors (or IndexedSlices, or None, or
+      CompositeTensor), one for each element in `sources`. Returned structure
+      is the same as the structure of `sources`.
+
+    Raises:
+      RuntimeError: If called on a used, non-persistent tape.
+      RuntimeError: If called inside the context of the tape.
+      TypeError: If the target is a None object.
+      ValueError: If the target is a variable or if unconnected gradients is
+       called with an unknown value.
+    """
+    if self._tape is None:
+      raise RuntimeError("A non-persistent GradientTape can only be used to "
+                         "compute one set of gradients (or jacobians)")
+    if self._recording:
+      if not self._persistent:
+        self._pop_tape()
+      else:
+        logging.log_first_n(
+            logging.WARN, "Calling GradientTape.gradient on a persistent "
+            "tape inside its context is significantly less "
+            "efficient than calling it outside the context (it "
+            "causes the gradient ops to be recorded on the "
+            "tape, leading to increased CPU and memory usage). "
+            "Only call GradientTape.gradient inside the "
+            "context if you actually want to trace the "
+            "gradient in order to compute higher order "
+            "derivatives.", 1)
+
+    if target is None:
+      raise TypeError("Argument `target` should be a list or nested structure"
+                      " of Tensors, Variables or CompositeTensors to be "
+                      "differentiated, but received None.")
+
+    flat_targets = composite_tensor_gradient.get_flat_tensors_for_gradients(
+        nest.flatten(target))
+    # TODO(b/246997907): Remove this once
+    # ResourceVariableGradient.get_gradient_components returns the handle.
+    flat_targets = nest.map_structure(_handle_or_self, flat_targets)
+
+    for t in flat_targets:
+      if not backprop_util.IsTrainable(t):
+        logging.vlog(
+            1, "The dtype of the target tensor must be "
+            "floating (e.g. tf.float32) when calling GradientTape.gradient, "
+            "got %r", t.dtype)
+
+    flat_sources_raw = nest.flatten(sources)
+    flat_sources = []
+    for t in flat_sources_raw:
+      flat_sources.append(_handle_or_self(t))
+    flat_sources = composite_tensor_gradient.get_flat_tensors_for_gradients(
+        flat_sources)
+    for t in flat_sources:
+      if not backprop_util.IsTrainable(t):
+        logging.vlog(
+            1, "The dtype of the source tensor must be "
+            "floating (e.g. tf.float32) when calling GradientTape.gradient, "
+            "got %r", t.dtype)
+      if getattr(t, "is_packed", False):
+        raise ValueError(
+            "GradientTape.gradient is not supported on packed EagerTensors yet."
+        )
+
+    if output_gradients is not None:
+      output_gradients = nest.flatten(
+          variable_utils.convert_variables_to_tensors(output_gradients))
+      output_gradients = (
+          composite_tensor_gradient.get_flat_tensors_for_gradients(
+              output_gradients))
+      output_gradients = [None if x is None else ops.convert_to_tensor(x)
+                          for x in output_gradients]
+
+    flat_grad = imperative_grad.imperative_grad(
+        self._tape,
+        flat_targets,
+        flat_sources,
+        output_gradients=output_gradients,
+        sources_raw=flat_sources_raw,
+        unconnected_gradients=unconnected_gradients)
+
+    if not self._persistent:
+      # Keep track of watched variables before setting tape to None
+      self._watched_variables = self._tape.watched_variables()
+      self._tape = None
+
+    flat_sources_raw = nest.map_structure(_handle_or_self, flat_sources_raw)
+    flat_grad = composite_tensor_gradient.replace_flat_tensors_for_gradients(
+        flat_sources_raw, flat_grad)
+    grad = nest.pack_sequence_as(sources, flat_grad)
+    return grad
+
+  def jacobian(self,
+               target,
+               sources,
+               unconnected_gradients=UnconnectedGradients.NONE,
+               parallel_iterations=None,
+               experimental_use_pfor=True):
+    """Computes the jacobian using operations recorded in context of this tape.
+
+    Note: Unless you set `persistent=True` a GradientTape can only be used to
+    compute one set of gradients (or jacobians).
+
+    Note: By default the jacobian implementation uses parallel for (pfor), which
+    creates a tf.function under the hood for each jacobian call. For better
+    performance, and to avoid recompilation and vectorization rewrites on each
+    call, enclose GradientTape code in @tf.function.
+
+    See[wikipedia
+    article](http://en.wikipedia.org/wiki/jacobian_matrix_and_determinant)
+    for the definition of a Jacobian.
+
+    Example usage:
+
+    ```python
+    with tf.GradientTape() as g:
+      x  = tf.constant([1.0, 2.0])
+      g.watch(x)
+      y = x * x
+    jacobian = g.jacobian(y, x)
+    # jacobian value is [[2., 0.], [0., 4.]]
+    ```
+
+    Args:
+      target: Tensor to be differentiated.
+      sources: a list or nested structure of Tensors or Variables. `target`
+        will be differentiated against elements in `sources`.
+      unconnected_gradients: a value which can either hold 'none' or 'zero' and
+        alters the value which will be returned if the target and sources are
+        unconnected. The possible values and effects are detailed in
+        'UnconnectedGradients' and it defaults to 'none'.
+      parallel_iterations: A knob to control how many iterations are dispatched
+        in parallel. This knob can be used to control the total memory usage.
+      experimental_use_pfor: If true, vectorizes the jacobian computation. Else
+        falls back to a sequential while_loop. Vectorization can sometimes fail
+        or lead to excessive memory usage. This option can be used to disable
+        vectorization in such cases.
+
+    Returns:
+      A list or nested structure of Tensors (or None), one for each element in
+      `sources`. Returned structure is the same as the structure of `sources`.
+      Note if any gradient is sparse (IndexedSlices), jacobian function
+      currently makes it dense and returns a Tensor instead. This may change in
+      the future.
+
+
+    Raises:
+      RuntimeError: If called on a used, non-persistent tape.
+      RuntimeError: If called on a non-persistent tape with eager execution
+        enabled and without enabling experimental_use_pfor.
+      ValueError: If vectorization of jacobian computation fails.
+    """
+    if self._tape is None:
+      raise RuntimeError("A non-persistent GradientTape can only be used to "
+                         "compute one set of gradients (or jacobians)")
+
+    flat_sources = nest.flatten(sources)
+    target_static_shape = target.shape
+    target_shape = array_ops.shape(target)
+    # Note that we push and pop the tape here and below. This is needed since we
+    # need gradients through the enclosed operations.
+    with self._ensure_recording():
+      target = array_ops.reshape(target, [-1])
+
+    def loop_fn(i):
+      with self._ensure_recording():
+        y = array_ops.gather(target, i)
+      return self.gradient(y, flat_sources,
+                           unconnected_gradients=unconnected_gradients)
+
+    try:
+      target_size = int(target.shape[0])
+    except TypeError:
+      target_size = array_ops.shape(target)[0]
+
+    if experimental_use_pfor:
+      try:
+        output = pfor_ops.pfor(loop_fn, target_size,
+                               parallel_iterations=parallel_iterations)
+      except ValueError as err:
+        raise ValueError(
+            "Encountered an exception while vectorizing the "
+            "jacobian computation. Vectorization can be disabled by setting"
+            " experimental_use_pfor to False.") from err
+    else:
+      if context.executing_eagerly() and not self._persistent:
+        raise RuntimeError(
+            "GradientTape must be created with persistent=True"
+            " to compute the jacobian with eager execution enabled and with "
+            " experimental_use_pfor set to False.")
+      output = pfor_ops.for_loop(
+          loop_fn, [target.dtype] * len(flat_sources), target_size,
+          parallel_iterations=parallel_iterations)
+
+    for i, out in enumerate(output):
+      if out is not None:
+        new_shape = array_ops.concat(
+            [target_shape, array_ops.shape(out)[1:]], axis=0)
+        out = array_ops.reshape(out, new_shape)
+        if context.executing_eagerly():
+          out.set_shape(target_static_shape.concatenate(flat_sources[i].shape))
+      output[i] = out
+
+    return nest.pack_sequence_as(sources, output)
+
+  def batch_jacobian(self,
+                     target,
+                     source,
+                     unconnected_gradients=UnconnectedGradients.NONE,
+                     parallel_iterations=None,
+                     experimental_use_pfor=True):
+    """Computes and stacks per-example jacobians.
+
+    See [wikipedia article](http://en.wikipedia.org/wiki/jacobian_matrix_and_determinant)
+    for the definition of a Jacobian. This function is essentially an efficient
+    implementation of the following:
+
+    `tf.stack([self.jacobian(y[i], x[i]) for i in range(x.shape[0])])`.
+
+    Note that compared to `GradientTape.jacobian` which computes gradient of
+    each output value w.r.t each input value, this function is useful when
+    `target[i,...]` is independent of `source[j,...]` for `j != i`. This
+    assumption allows more efficient computation as compared to
+    `GradientTape.jacobian`. The output, as well as intermediate activations,
+    are lower dimensional and avoid a bunch of redundant zeros which would
+    result in the jacobian computation given the independence assumption.
+
+    Note: Unless you set `persistent=True` a GradientTape can only be used to
+    compute one set of gradients (or jacobians).
+
+    Note: By default the batch_jacobian implementation uses parallel for (pfor),
+    which creates a tf.function under the hood for each batch_jacobian call.
+    For better performance, and to avoid recompilation and vectorization
+    rewrites on each call, enclose GradientTape code in @tf.function.
+
+
+    Example usage:
+
+    ```python
+    with tf.GradientTape() as g:
+      x = tf.constant([[1., 2.], [3., 4.]], dtype=tf.float32)
+      g.watch(x)
+      y = x * x
+    batch_jacobian = g.batch_jacobian(y, x)
+    # batch_jacobian is [[[2,  0], [0,  4]], [[6,  0], [0,  8]]]
+    ```
+
+    Args:
+      target: A tensor with rank 2 or higher and with shape [b, y1, ..., y_n].
+        `target[i,...]` should only depend on `source[i,...]`.
+      source: A tensor with rank 2 or higher and with shape [b, x1, ..., x_m].
+      unconnected_gradients: a value which can either hold 'none' or 'zero' and
+        alters the value which will be returned if the target and sources are
+        unconnected. The possible values and effects are detailed in
+        'UnconnectedGradients' and it defaults to 'none'.
+      parallel_iterations: A knob to control how many iterations are dispatched
+        in parallel. This knob can be used to control the total memory usage.
+      experimental_use_pfor: If true, uses pfor for computing the Jacobian. Else
+        uses a tf.while_loop.
+
+    Returns:
+      A tensor `t` with shape [b, y_1, ..., y_n, x1, ..., x_m] where `t[i, ...]`
+      is the jacobian of `target[i, ...]` w.r.t. `source[i, ...]`, i.e. stacked
+      per-example jacobians.
+
+    Raises:
+      RuntimeError: If called on a used, non-persistent tape.
+      RuntimeError: If called on a non-persistent tape with eager execution
+        enabled and without enabling experimental_use_pfor.
+      ValueError: If vectorization of jacobian computation fails or if first
+        dimension of `target` and `source` do not match.
+    """
+    if self._tape is None:
+      raise RuntimeError("A non-persistent GradientTape can only be used to"
+                         "compute one set of gradients (or jacobians)")
+    target_shape = target.shape
+    if target_shape.rank is None:
+      dim = tensor_shape.Dimension(None)
+    else:
+      dim = target_shape.dims[0]
+    if not (target_shape.with_rank_at_least(2) and
+            source.shape.with_rank_at_least(2) and
+            dim.is_compatible_with(source.shape[0])):
+      raise ValueError(
+          "Need first dimension of target shape (%s) and "
+          "source shape (%s) to match." % (target.shape, source.shape))
+    if target_shape.is_fully_defined():
+      batch_size = int(target_shape[0])
+      target_row_size = target_shape.num_elements() // batch_size
+    else:
+      target_shape = array_ops.shape(target)
+      batch_size = target_shape[0]
+      target_row_size = array_ops.size(target) // batch_size
+    source_shape = array_ops.shape(source)
+    # Flatten target to 2-D.
+    # Note that we push and pop the tape here and below. This is needed since we
+    # need gradients through the enclosed operations.
+    with self._ensure_recording():
+      with ops.control_dependencies(
+          [check_ops.assert_equal(batch_size, source_shape[0])]):
+        target = array_ops.reshape(target, [batch_size, target_row_size])
+
+    run_once = False
+
+    def loop_fn(i):
+      nonlocal run_once
+      if run_once and not self._persistent:
+        if parallel_iterations is not None:
+          raise RuntimeError(
+              "GradientTape must be created with persistent=True"
+              " to compute the batch_jacobian with parallel_iterations.")
+        else:
+          raise RuntimeError(
+              "GradientTape must be created with persistent=True"
+              " to compute the batch_jacobian.")
+      run_once = True
+
+      with self._ensure_recording():
+        y = array_ops.gather(target, i, axis=1)
+      return self.gradient(y, source,
+                           unconnected_gradients=unconnected_gradients)
+
+    if experimental_use_pfor:
+      try:
+        output = pfor_ops.pfor(loop_fn, target_row_size,
+                               parallel_iterations=parallel_iterations)
+      except ValueError as err:
+        raise ValueError(
+            "Encountered an exception while vectorizing the "
+            "batch_jacobian computation. Vectorization can be disabled by "
+            "setting experimental_use_pfor to False.") from err
+    else:
+      if context.executing_eagerly() and not self._persistent:
+        raise RuntimeError(
+            "GradientTape must be created with persistent=True"
+            " to compute the batch_jacobian with eager execution enabled and "
+            " with experimental_use_pfor set to False.")
+      output = pfor_ops.for_loop(loop_fn, target.dtype, target_row_size,
+                                 parallel_iterations=parallel_iterations)
+    new_shape = array_ops.concat([target_shape, source_shape[1:]], axis=0)
+    if output is None:
+      # Note that this block is returning zeros when it could use `None` to
+      # represent unconnected gradients. This is to maintain compatibility with
+      # the previous behavior, which ignored `unconnected_gradients`.
+      output = array_ops.zeros(new_shape, target.dtype)
+      return output
+    else:
+      output = array_ops.reshape(output,
+                                 [target_row_size, batch_size, -1])
+      output = array_ops.transpose(output, [1, 0, 2])
+
+      output = array_ops.reshape(output, new_shape)
+      return output

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/backprop_util.py

@@ -0,0 +1,105 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Shared utilities related to backprop."""
+
+from tensorflow.core.config import flags
+from tensorflow.core.framework import types_pb2
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import indexed_slices
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor as tensor_lib
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import handle_data_util
+from tensorflow.python.ops import math_ops
+
+
+def _DTypeFromTensor(tensor):
+  """Extract either `tensor.dtype` or the unanimous sub-type of a variant."""
+  dtype = tensor.dtype
+  if dtype.base_dtype == dtypes.variant:
+    # If we know statically that the data a variant points to is non-trainable
+    # then the variant itself is non-trainable.
+    if isinstance(tensor, ops.EagerTensor):
+      handle_data = tensor._handle_data  # pylint: disable=protected-access
+    else:
+      handle_data = handle_data_util.get_resource_handle_data(tensor)
+    if (handle_data is not None
+        and handle_data.is_set
+        and handle_data.shape_and_type):
+      first_type = handle_data.shape_and_type[0].dtype
+      # Some variants have statically unknown dtypes; we can't make inferences
+      # about trainability, so we conservatively assume they're trainable
+      # (which may waste memory passing zeros around, but will be correct).
+      if (first_type != types_pb2.DT_INVALID
+          and all(shape_and_type.dtype == first_type
+                  for shape_and_type in handle_data.shape_and_type)):
+        return first_type
+  return dtype
+
+
+def IsTrainable(tensor_or_dtype):
+  """Determines whether a tensor or dtype supports infinitesimal changes."""
+  if tensor_util.is_tf_type(tensor_or_dtype):
+    dtype = _DTypeFromTensor(tensor_or_dtype)
+  else:
+    dtype = tensor_or_dtype
+  dtype = dtypes.as_dtype(dtype)
+  trainable_dtypes = [dtypes.float16, dtypes.float32, dtypes.float64,
+                      dtypes.complex64, dtypes.complex128, dtypes.resource,
+                      dtypes.variant, dtypes.bfloat16]
+  if flags.config().enable_quantized_dtypes_training.value():
+    trainable_dtypes.extend([dtypes.qint8, dtypes.qint16, dtypes.qint32,
+                             dtypes.quint8, dtypes.quint16])
+  return dtype.base_dtype in trainable_dtypes
+
+
+def FlattenNestedIndexedSlices(grad):
+  assert isinstance(grad, indexed_slices.IndexedSlices)
+  if isinstance(grad.values, tensor_lib.Tensor):
+    return grad
+  else:
+    assert isinstance(grad.values, indexed_slices.IndexedSlices)
+    g = FlattenNestedIndexedSlices(grad.values)
+    return indexed_slices.IndexedSlices(
+        g.values, array_ops.gather(grad.indices, g.indices), g.dense_shape)
+
+
+def AggregateIndexedSlicesGradients(grads):
+  """Aggregates gradients containing `IndexedSlices`s."""
+  if len(grads) < 1:
+    return None
+  if len(grads) == 1:
+    return grads[0]
+  grads = [g for g in grads if g is not None]
+  # If any gradient is a `Tensor`, sum them up and return a dense tensor
+  # object.
+  if any(isinstance(g, tensor_lib.Tensor) for g in grads):
+    return math_ops.add_n(grads)
+
+  # The following `_as_indexed_slices_list` casts ids of IndexedSlices into
+  # int64. It is to make sure the inputs of `concat` all have same the data
+  # type.
+  grads = math_ops._as_indexed_slices_list(grads)  # pylint: disable=protected-access
+
+  grads = [FlattenNestedIndexedSlices(x) for x in grads]
+  # Form IndexedSlices out of the concatenated values and indices.
+  concat_grad = indexed_slices.IndexedSlices(
+      array_ops.concat([x.values for x in grads], axis=0),
+      array_ops.concat([x.indices for x in grads], axis=0),
+      grads[0].dense_shape)
+
+  return concat_grad
+

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/benchmarks_test_base.py

@@ -0,0 +1,77 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+r"""Benchmark base to run and report benchmark results."""
+
+import os
+import uuid
+
+from tensorflow.python.eager import test
+from tensorflow.python.platform import flags
+from tensorflow.python.profiler import profiler_v2 as profiler
+
+flags.DEFINE_bool("xprof", False, "Run and report benchmarks with xprof on")
+flags.DEFINE_string("logdir", "/tmp/xprof/", "Directory to store xprof data")
+
+
+class MicroBenchmarksBase(test.Benchmark):
+  """Run and report benchmark results.
+
+  The first run is without any profilng.
+  Second run is with xprof and python trace. Third run is with xprof without
+  python trace. Note: xprof runs are with fewer iterations.
+  """
+
+  def run_with_xprof(self, enable_python_trace, run_benchmark, func,
+                     num_iters_xprof, execution_mode, suid):
+    if enable_python_trace:
+      options = profiler.ProfilerOptions(python_tracer_level=1)
+      logdir = os.path.join(flags.FLAGS.logdir, suid + "_with_python")
+    else:
+      options = profiler.ProfilerOptions(python_tracer_level=0)
+      logdir = os.path.join(flags.FLAGS.logdir, suid)
+    with profiler.Profile(logdir, options):
+      total_time = run_benchmark(func, num_iters_xprof, execution_mode)
+    us_per_example = float("{0:.3f}".format(total_time * 1e6 / num_iters_xprof))
+    return logdir, us_per_example
+
+  def run_report(self, run_benchmark, func, num_iters, execution_mode=None):
+    """Run and report benchmark results."""
+    total_time = run_benchmark(func, num_iters, execution_mode)
+    mean_us = total_time * 1e6 / num_iters
+    extras = {
+        "examples_per_sec": float("{0:.3f}".format(num_iters / total_time)),
+        "us_per_example": float("{0:.3f}".format(total_time * 1e6 / num_iters))
+    }
+
+    if flags.FLAGS.xprof:
+      suid = str(uuid.uuid4())
+      # Re-run with xprof and python trace.
+      num_iters_xprof = min(100, num_iters)
+      xprof_link, us_per_example = self.run_with_xprof(True, run_benchmark,
+                                                       func, num_iters_xprof,
+                                                       execution_mode, suid)
+      extras["xprof link with python trace"] = xprof_link
+      extras["us_per_example with xprof and python"] = us_per_example
+
+      # Re-run with xprof but no python trace.
+      xprof_link, us_per_example = self.run_with_xprof(False, run_benchmark,
+                                                       func, num_iters_xprof,
+                                                       execution_mode, suid)
+      extras["xprof link"] = xprof_link
+      extras["us_per_example with xprof"] = us_per_example
+
+    benchmark_name = self._get_benchmark_name()
+    self.report_benchmark(
+        iters=num_iters, wall_time=mean_us, extras=extras, name=benchmark_name)

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/cancellation.py

@@ -0,0 +1,62 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Cancellation support for eager execution."""
+
+from tensorflow.python import pywrap_tfe
+
+
+class CancellationManager(object):
+  """A mechanism for cancelling blocking computation."""
+
+  __slots__ = ["_impl"]
+
+  def __init__(self):
+    self._impl = pywrap_tfe.TFE_NewCancellationManager()
+
+  @property
+  def is_cancelled(self):
+    """Returns `True` if `CancellationManager.start_cancel` has been called."""
+    return pywrap_tfe.TFE_CancellationManagerIsCancelled(self._impl)
+
+  def start_cancel(self):
+    """Cancels blocking operations that have been registered with this object."""
+    pywrap_tfe.TFE_CancellationManagerStartCancel(self._impl)
+
+  def get_cancelable_function(self, concrete_function):
+    def cancellable(*args, **kwargs):
+      with CancellationManagerContext(self):
+        return concrete_function(*args, **kwargs)
+    return cancellable
+
+_active_context = None
+
+
+def context():
+  return _active_context
+
+
+class CancellationManagerContext:
+  """A Python context for wrapping a cancellable ConcreteFunction."""
+
+  def __init__(self, cancellation_manager):
+    self._cancellation_manager = cancellation_manager
+
+  def __enter__(self):
+    global _active_context
+    _active_context = self._cancellation_manager
+
+  def __exit__(self, exc_type, exc_value, exc_tb):
+    global _active_context
+    _active_context = None

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/core.py

@@ -0,0 +1,78 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Experimental API for TensorFlow's "Eager" mode of execution."""
+
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.framework import errors
+from tensorflow.python.platform import tf_logging as logging
+
+# Trace of execution and memory usage.
+_active_trace = None
+
+
+def _status_to_exception(status):
+  try:
+    error_class = errors.exception_type_from_error_code(status.code)
+    e = error_class(None, None, status.message, status.payloads)
+    logging.error_log("%s: %s" % (e.__class__.__name__, e))
+    return e
+  except KeyError:
+    e = errors.UnknownError(
+        None, None, status.message, status.code, status.payloads
+    )
+    logging.error_log("%s: %s" % (e.__class__.__name__, e))
+    return e
+
+
+class _NotOkStatusException(Exception):
+  """Exception class to handle not ok Status."""
+
+  def __init__(self, message, code, payloads):
+    super(_NotOkStatusException, self).__init__()
+    self.message = message
+    self.code = code
+    self.payloads = payloads
+
+  def __str__(self):
+    e = _status_to_exception(self)
+    return "%s: %s" % (e.__class__.__name__, e)
+
+
+pywrap_tfe.TFE_Py_RegisterExceptionClass(_NotOkStatusException)
+
+
+class _FallbackException(Exception):
+  """Exception class to handle fallback from the fastpath.
+
+  The fastpath that we refer to here is the one implemented to reduce per-op
+  overheads (TFE_Py_FastPathExecute_C). If the conditions for executing the op
+  on the fastpath are not met, we fallback to a safer (and more complete)
+  slowpath, and this Exception is raised to signal that transition.
+  """
+  pass
+
+
+class _SymbolicException(Exception):
+  """Exception class to handle use of symbolic tensors when executing eagerly.
+
+  `keras.Input()` creates symbolic tensors (in a FuncGraph managed by the
+  Keras backend) while in eager execution. This exception is used to
+  identify this case (raised in `convert_to_tensor` cause generated functions
+  for ops to construct graphs instead of executing the kernel).
+  """
+  pass
+
+
+pywrap_tfe.TFE_Py_RegisterFallbackExceptionClass(_FallbackException)

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py

@@ -0,0 +1,28 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Supports old symbols supplied by this file while the code is refactored."""
+
+# pylint:disable=unused-import,g-bad-import-order
+
+# Config Options
+from tensorflow.python.eager.polymorphic_function.eager_function_run import run_functions_eagerly
+from tensorflow.python.eager.polymorphic_function.eager_function_run import functions_run_eagerly
+
+# tf.function Classes
+from tensorflow.python.eager.polymorphic_function.polymorphic_function import Function
+from tensorflow.python.eager.polymorphic_function.polymorphic_function import function
+
+# Private attributes
+from tensorflow.python.eager.polymorphic_function.polymorphic_function import _tf_function_counter

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/execute.py

@@ -0,0 +1,329 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Functions called by the generated code to execute an eager-mode op."""
+
+from google.protobuf import text_format
+from tensorflow.core.framework import tensor_pb2
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.eager import core
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import tensor_conversion_registry
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.types import core as core_types
+from tensorflow.python.util import compat
+
+
+def quick_execute(op_name, num_outputs, inputs, attrs, ctx, name=None):
+  """Execute a TensorFlow operation.
+
+  Args:
+    op_name: Name of the TensorFlow operation (see REGISTER_OP in C++ code) to
+      execute.
+    num_outputs: The number of outputs of the operation to fetch. (Explicitly
+      provided instead of being inferred for performance reasons).
+    inputs: A list of inputs to the operation. Each entry should be a Tensor, or
+      a value which can be passed to the Tensor constructor to create one.
+    attrs: A tuple with alternating string attr names and attr values for this
+      operation.
+    ctx: The value of context.context().
+    name: Customized name for the operation.
+
+  Returns:
+    List of output Tensor objects. The list is empty if there are no outputs
+
+  Raises:
+    An exception on error.
+  """
+  device_name = ctx.device_name
+  # pylint: disable=protected-access
+  try:
+    ctx.ensure_initialized()
+    tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,
+                                        inputs, attrs, num_outputs)
+  except core._NotOkStatusException as e:
+    if name is not None:
+      e.message += " name: " + name
+    raise core._status_to_exception(e) from None
+  except TypeError as e:
+    keras_symbolic_tensors = [x for x in inputs if _is_keras_symbolic_tensor(x)]
+    if keras_symbolic_tensors:
+      raise core._SymbolicException(
+          "Inputs to eager execution function cannot be Keras symbolic "
+          "tensors, but found {}".format(keras_symbolic_tensors))
+    raise e
+  # pylint: enable=protected-access
+  return tensors
+
+
+def execute_with_cancellation(op_name,
+                              num_outputs,
+                              inputs,
+                              attrs,
+                              ctx,
+                              cancellation_manager,
+                              name=None):
+  """Execute a TensorFlow operation.
+
+  Args:
+    op_name: Name of the TensorFlow operation (see REGISTER_OP in C++ code) to
+      execute.
+    num_outputs: The number of outputs of the operation to fetch. (Explicitly
+      provided instead of being inferred for performance reasons).
+    inputs: A list of inputs to the operation. Each entry should be a Tensor, or
+      a value which can be passed to the Tensor constructor to create one.
+    attrs: A tuple with alternating string attr names and attr values for this
+      operation.
+    ctx: The value of context.context().
+    cancellation_manager: a `CancellationManager` object that can be used to
+      cancel the operation.
+    name: Customized name for the operation.
+
+  Returns:
+    List of output Tensor objects. The list is empty if there are no outputs
+
+  Raises:
+    An exception on error.
+  """
+  device_name = ctx.device_name
+  # pylint: disable=protected-access
+  try:
+    ctx.ensure_initialized()
+    tensors = pywrap_tfe.TFE_Py_ExecuteCancelable(ctx._handle, device_name,
+                                                  op_name, inputs, attrs,
+                                                  cancellation_manager._impl,
+                                                  num_outputs)
+  except core._NotOkStatusException as e:
+    if name is not None:
+      e.message += " name: " + name
+    raise core._status_to_exception(e) from None
+  except TypeError as e:
+    keras_symbolic_tensors = [x for x in inputs if _is_keras_symbolic_tensor(x)]
+    if keras_symbolic_tensors:
+      raise core._SymbolicException(
+          "Inputs to eager execution function cannot be Keras symbolic "
+          "tensors, but found {}".format(keras_symbolic_tensors))
+    raise e
+  # pylint: enable=protected-access
+  return tensors
+
+
+def execute_with_callbacks(op_name, num_outputs, inputs, attrs, ctx, name=None):
+  """Monkey-patch to execute to enable execution callbacks."""
+  tensors = quick_execute(op_name, num_outputs, inputs, attrs, ctx, name)
+  for callback in ctx.op_callbacks:
+    callback(op_name, tuple(inputs), attrs, tensors, name)
+
+  return tensors
+
+
+execute = quick_execute
+
+
+def must_record_gradient():
+  """Import backprop if you want gradients recorded."""
+  return False
+
+
+def record_gradient(unused_op_name, unused_inputs, unused_attrs,
+                    unused_outputs):
+  """Import backprop if you want gradients recorded."""
+  pass
+
+
+def make_float(v, arg_name):
+  if not isinstance(v, compat.real_types):
+    raise TypeError("Expected float for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+  return float(v)
+
+
+def make_int(v, arg_name):
+  if isinstance(v, str):
+    raise TypeError("Expected int for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+  try:
+    return int(v)
+  except (ValueError, TypeError):
+    raise TypeError("Expected int for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+
+
+def make_str(v, arg_name):
+  if not isinstance(v, compat.bytes_or_text_types):
+    raise TypeError("Expected string for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+  return compat.as_bytes(v)  # Convert unicode strings to bytes.
+
+
+def make_bool(v, arg_name):
+  if not isinstance(v, bool):
+    raise TypeError("Expected bool for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+  return v
+
+
+def make_type(v, arg_name):
+  try:
+    v = dtypes.as_dtype(v).base_dtype
+  except TypeError:
+    raise TypeError("Expected DataType for argument '%s' not %s." %
+                    (arg_name, repr(v)))
+  i = v.as_datatype_enum
+  return i
+
+
+def make_shape(v, arg_name):
+  """Convert v into a list."""
+  # Args:
+  #   v: A TensorShapeProto, a list of ints, or a tensor_shape.TensorShape.
+  #   arg_name: String, for error messages.
+
+  # Returns:
+  #   None if the rank is unknown, otherwise a list of ints (or Nones in the
+  #   position where the dimension is unknown).
+  try:
+    shape = tensor_shape.as_shape(v)
+  except TypeError as e:
+    raise TypeError("Error converting %s to a TensorShape: %s." % (arg_name, e))
+  except ValueError as e:
+    raise ValueError("Error converting %s to a TensorShape: %s." %
+                     (arg_name, e))
+  if shape.ndims is None:
+    return None
+  else:
+    return shape.as_list()
+
+
+def make_tensor(v, arg_name):
+  """Ensure v is a TensorProto."""
+  if isinstance(v, tensor_pb2.TensorProto):
+    return v
+  elif isinstance(v, str):
+    pb = tensor_pb2.TensorProto()
+    text_format.Merge(v, pb)
+    return pb
+  raise TypeError(
+      "Don't know how to convert %s to a TensorProto for argument '%s'." %
+      (repr(v), arg_name))
+
+
+def args_to_matching_eager(l, ctx, allowed_dtypes, default_dtype=None):
+  """Convert sequence `l` to eager same-type Tensors."""
+  del ctx  # Unused
+  if (not l) and (default_dtype is not None):
+    return default_dtype, []  # List is empty; assume default dtype.
+  for x in l:
+    if not isinstance(x, core_types.Value):
+      break
+  else:  # note: intentional for-else
+    return l[0]._datatype_enum(), l  # pylint: disable=protected-access
+
+  # Is some input already a Tensor with a dtype?
+  dtype = None
+  for t in l:
+    if isinstance(t, core_types.Value):
+      dtype = t.dtype
+      break
+
+  if dtype is None:
+    # Infer a dtype based on the first value, and use that dtype for the
+    # remaining values.
+
+    ret = []
+    for t in l:
+      tensor = None
+      # First see if we can get a valid dtype with the default conversion
+      # and see if it matches an allowed dtypes. Some ops like ConcatV2 may
+      # not list allowed dtypes, in which case we should skip this.
+      if dtype is None and allowed_dtypes:
+        tensor = tensor_conversion_registry.convert(t)
+        # If we did not match an allowed dtype, try again with the default
+        # dtype. This could be because we have an empty tensor and thus we
+        # picked the wrong type.
+        if tensor.dtype not in allowed_dtypes:
+          tensor = None
+
+      if tensor is None:
+        tensor = tensor_conversion_registry.convert(
+            t, dtype, preferred_dtype=default_dtype
+        )
+
+      ret.append(tensor)
+      if dtype is None:
+        dtype = tensor.dtype
+  else:
+    ret = [tensor_conversion_registry.convert(t, dtype) for t in l]
+
+  # TODO(slebedev): consider removing this as it leaks a Keras concept.
+  # pylint: disable=protected-access
+  keras_symbolic_tensors = [x for x in ret if _is_keras_symbolic_tensor(x)]
+  if keras_symbolic_tensors:
+    raise core._SymbolicException(
+        "Using symbolic output of a Keras layer during eager execution "
+        "{}".format(keras_symbolic_tensors))
+  # pylint: enable=protected-access
+  return dtype.as_datatype_enum, ret
+
+
+def convert_to_mixed_eager_tensors(values, ctx):
+  del ctx  # Unused
+  v = [tensor_conversion_registry.convert(t) for t in values]
+  types = [t._datatype_enum() for t in v]  # pylint: disable=protected-access
+  return types, v
+
+
+def args_to_mixed_eager_tensors(lists, ctx):
+  """Converts a list of same-length lists of values to eager tensors."""
+  del ctx  # Unused
+  assert len(lists) > 1
+
+  # Generate an error if len(lists[i]) is not the same for all i.
+  lists_ret = [[]]
+  for l in lists[1:]:
+    if len(l) != len(lists[0]):
+      raise ValueError(
+          "Expected list arguments to be the same length: %d != %d (%r vs. %r)."
+          % (len(lists[0]), len(l), lists[0], l))
+    lists_ret.append([])
+
+  # Convert the first element of each list first, then the second element, etc.
+  types = []
+  for i in range(len(lists[0])):
+    dtype = None
+    # If any list has a Tensor, use that dtype
+    for l in lists:
+      if isinstance(l[i], core_types.Value):
+        dtype = l[i].dtype
+        break
+    if dtype is None:
+      # Convert the first one and use its dtype.
+      lists_ret[0].append(tensor_conversion_registry.convert(lists[0][i]))
+      dtype = lists_ret[0][i].dtype
+      for j in range(1, len(lists)):
+        lists_ret[j].append(
+            tensor_conversion_registry.convert(lists[j][i], dtype=dtype)
+        )
+    else:
+      # Convert everything to the found dtype.
+      for j in range(len(lists)):
+        lists_ret[j].append(
+            tensor_conversion_registry.convert(lists[j][i], dtype=dtype)
+        )
+    types.append(dtype.as_datatype_enum)
+  return types, lists_ret
+
+
+def _is_keras_symbolic_tensor(x):
+  return hasattr(x, "graph") and getattr(x.graph, "name", None) == "keras_graph"

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/executor.py

@@ -0,0 +1,77 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Executor for eager execution."""
+
+from tensorflow.python import pywrap_tfe
+
+
+class Executor(object):
+  """A class for handling eager execution.
+
+  The default behavior for asynchronous execution is to serialize all ops on
+  a single thread. Having different `Executor` objects in different threads
+  enables executing ops asynchronously in parallel:
+
+  ```python
+  def thread_function():
+    executor = executor.Executor(enable_async=True):
+    context.set_executor(executor)
+
+  a = threading.Thread(target=thread_function)
+  a.start()
+  b = threading.Thread(target=thread_function)
+  b.start()
+  ```
+  """
+
+  __slots__ = ["_handle"]
+
+  def __init__(self, handle):
+    self._handle = handle
+
+  def __del__(self):
+    try:
+      self.wait()
+      pywrap_tfe.TFE_DeleteExecutor(self._handle)
+    except TypeError:
+      # Suppress some exceptions, mainly for the case when we're running on
+      # module deletion. Things that can go wrong include the pywrap module
+      # already being unloaded, self._handle. no longer being
+      # valid, and so on. Printing warnings in these cases is silly
+      # (exceptions raised from __del__ are printed as warnings to stderr).
+      pass  # 'NoneType' object is not callable when the handle has been
+      # partially unloaded.
+
+  def is_async(self):
+    return pywrap_tfe.TFE_ExecutorIsAsync(self._handle)
+
+  def handle(self):
+    return self._handle
+
+  def wait(self):
+    """Waits for ops dispatched in this executor to finish."""
+    pywrap_tfe.TFE_ExecutorWaitForAllPendingNodes(self._handle)
+
+  def clear_error(self):
+    """Clears errors raised in this executor during execution."""
+    pywrap_tfe.TFE_ExecutorClearError(self._handle)
+
+
+def new_executor(enable_async,
+                 enable_streaming_enqueue=True,
+                 in_flight_nodes_limit=0):
+  handle = pywrap_tfe.TFE_NewExecutor(enable_async, enable_streaming_enqueue,
+                                      in_flight_nodes_limit)
+  return Executor(handle)

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/forwardprop.py

@@ -0,0 +1,487 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for forward-mode automatic differentiation."""
+
+import functools
+import threading
+
+from tensorflow.core.function.polymorphism import function_cache
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.eager import backprop
+from tensorflow.python.eager import backprop_util
+from tensorflow.python.eager import execute
+from tensorflow.python.eager import forwardprop_util
+from tensorflow.python.eager.polymorphic_function import tracing_compilation
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops.parallel_for import control_flow_ops
+from tensorflow.python.ops.unconnected_gradients import UnconnectedGradients
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util import nest
+from tensorflow.python.util.tf_export import tf_export
+
+
+# Dictionary mapping from op names to special-cased jvp functions. Otherwise
+# backward functions are transposed on the tape.
+_SPECIAL_CASES = {}
+
+
+def _identity_jvp(attr_tuple, inputs, outputs, tangents):
+  # Special-cased mostly for resource handles, where creating ones Tensors from
+  # handle data for transposing the backward function on the tape is error-prone
+  # (even if we get good handle data, partially defined shapes are an issue).
+  del attr_tuple, inputs, outputs
+  return [array_ops.identity(t) for t in tangents]
+
+
+_SPECIAL_CASES["Identity"] = _identity_jvp
+
+
+def _read_variable_jvp(attr_tuple, inputs, outputs, tangents):
+  # Like for Identity, this special case means we don't need to create
+  # variable-shaped Tensors from resource handles.
+  del attr_tuple, inputs, outputs
+  return [array_ops.identity(t) for t in tangents]
+
+
+_SPECIAL_CASES["ReadVariableOp"] = _read_variable_jvp
+
+
+_TRACE_COUNT_CONSISTENCY_LOCK = threading.Lock()
+# Map from op names to number of traces of _jvp_helper. Used to cap the number
+# of traces due to shape differences while still specializing where possible.
+_TRACE_COUNT = {}
+
+
+def _jvp_helper(op_name, attr_tuple, inputs, outputs, tangents):
+  """Computes a Jacobian-vector product for an op.
+
+  Note that this function would be wasteful if executed eagerly. It runs the
+  backward gradient function and throws away the result just to record its
+  operations on a GradientTape. These unused ops are pruned away when this
+  function is traced.
+
+  Args:
+    op_name: A string, the type of operation being executed.
+    attr_tuple: Attributes of the operation.
+    inputs: A flat list of input Tensors to the operation.
+    outputs: A flat list of output Tensors from the operation.
+    tangents: A flat list of Tensors, same shape as `inputs`.
+
+  Returns:
+    A flat list of tangents corresponding to `outputs`.
+  """
+  with _TRACE_COUNT_CONSISTENCY_LOCK:
+    # Just make sure writes don't clobber each other's increments; reads in
+    # _jvp_dispatch do not lock.
+    _TRACE_COUNT[op_name] = _TRACE_COUNT.get(op_name, 0) + 1
+
+  special_case = _SPECIAL_CASES.get(op_name, None)
+  if special_case is not None:
+    return special_case(attr_tuple, inputs, outputs, tangents)
+  if not outputs:
+    # tape.gradients([], inputs) doesn't make much sense
+    return []
+  # Generally inner GradientTapes won't function while outer accumulators are
+  # recording. We temporarily reset forwardprop state to allow GradientTapes to
+  # function here.
+  with forwardprop_util.push_forwardprop_state():
+    trainable_inputs = []
+    trainable_indices = []
+    nontrivial_tangents = []
+    for input_index, tensor in enumerate(inputs):
+      if backprop_util.IsTrainable(tensor):
+        trainable_inputs.append(tensor)
+        trainable_indices.append(input_index)
+        nontrivial_tangents.append(tangents[input_index])
+
+    with backprop.GradientTape() as transpose_tape:
+      with backprop.GradientTape() as backfunc_tape:
+        backfunc_tape.watch(trainable_inputs)
+        execute.record_gradient(op_name, inputs, attr_tuple, outputs)
+
+      forwardprop_aids = []
+      trainable_outputs = []
+      nontrivial_output_indices = []
+      for output_index, output in enumerate(outputs):
+        if backprop_util.IsTrainable(output):
+          forwardprop_aids.append(
+              array_ops.ones_like(output, name="unused_forwardprop_aid"))
+          trainable_outputs.append(output)
+          nontrivial_output_indices.append(output_index)
+
+      transpose_tape.watch(forwardprop_aids)
+      grads = backfunc_tape.gradient(
+          trainable_outputs,
+          trainable_inputs,
+          forwardprop_aids,
+          unconnected_gradients=UnconnectedGradients.ZERO)
+    nontrivial_output_tangents = transpose_tape.gradient(
+        grads, forwardprop_aids, output_gradients=nontrivial_tangents)
+    output_tangents = [None] * len(outputs)
+    for index, tangent in zip(nontrivial_output_indices,
+                              nontrivial_output_tangents):
+      output_tangents[index] = tangent
+    return output_tangents
+
+
+def _jvp_helper_wrapper(op_name, attr_tuple, inputs, outputs, tangents,
+                        use_batch):
+  """Computes a batch of Jacobian-vector product for an op.
+
+  Args:
+    op_name: A string, the type of operation being executed.
+    attr_tuple: Attributes of the operation.
+    inputs: A flat list of input Tensors to the operation.
+    outputs: A flat list of output Tensors from the operation.
+    tangents: A flat list of Tensors, compatible with shape `[None] +
+      input_shape`.
+    use_batch: A bool, True to vetorize over batch of tangents of shape `[None]
+      + input_shape`.
+
+  Returns:
+    A flat list of tangents compatible with `outputs`
+    or `[None] + output_shape`.
+
+  Raises:
+    ValueError: if tangent shapes are not compatible with input shapes.
+  """
+  if use_batch:
+    for primal, tangent in zip(inputs, tangents):
+      if not tangent.shape.is_compatible_with([None] + primal.shape):
+        raise ValueError("Tangent {} was expected to be of shape "
+                         "{} but is instead of shape {}".format(
+                             tangent, [None] + primal.shape, tangent.shape))
+
+    return control_flow_ops.vectorized_map(
+        functools.partial(_jvp_helper, op_name, attr_tuple, inputs, outputs),
+        tangents,
+    )
+  return _jvp_helper(op_name, attr_tuple, inputs, outputs, tangents)
+
+
+# TODO(allenl): reduce_retracing for gradients which rely on static
+# shape information are underspecialized. We may want hand-written forward
+# implementations, or a more satisfying story about how we re-specialize
+# gradients which were traced with relaxed shapes (e.g. use conds instead of
+# trace-time Python logic).
+#
+# Using function.defun rather than def_function.function avoids
+# tf.config.run_functions_eagerly(True). `_jvp_helper` doesn't successfully run
+# eagerly (infinite recursion), and even if it did it would use extra memory and
+# run unnecessary computation. The function does not create variables, so the
+# two symbols are otherwise equivalent.
+_jvp_function_cache = function_cache.FunctionCache()
+_jvp_relaxed_config = tracing_compilation.TracingOptions(
+    _jvp_helper_wrapper,
+    name="_jvp_relaxed_shapes",
+    reduce_retracing=True,
+    function_cache=_jvp_function_cache,
+)
+
+_jvp_exact_config = tracing_compilation.TracingOptions(
+    _jvp_helper_wrapper,
+    name="_jvp_exact_shapes",
+    reduce_retracing=False,
+    function_cache=_jvp_function_cache,
+)
+
+# The maximum number of exact-shape traces to perform for a single op before
+# switching to shape relaxation.
+_TRACE_COUNT_LIMIT = 32
+
+
+def _jvp_dispatch(op_name,
+                  attr_tuple,
+                  inputs,
+                  outputs,
+                  tangents,
+                  use_batch=False):
+  """Determine which forwardprop function to call."""
+  # Note that this _TRACE_COUNT read races with writes. That's fine, it just
+  # means we may trace a few more exact shapes before moving on to relaxation.
+  if _TRACE_COUNT.get(op_name, 0) < _TRACE_COUNT_LIMIT:
+    config = _jvp_exact_config
+  else:
+    config = _jvp_relaxed_config
+  return tracing_compilation.call_function(
+      (op_name, attr_tuple, inputs, outputs, tangents, use_batch),
+      tracing_options=config,
+  )
+
+
+pywrap_tfe.TFE_Py_RegisterJVPFunction(_jvp_dispatch)
+
+
+@tf_export("autodiff.ForwardAccumulator", v1=[])
+class ForwardAccumulator():
+  """Computes Jacobian-vector products ("JVP"s) using forward-mode autodiff.
+
+  Compare to `tf.GradientTape` which computes vector-Jacobian products ("VJP"s)
+  using reverse-mode autodiff (backprop). Reverse mode is more attractive when
+  computing gradients of a scalar-valued function with respect to many inputs
+  (e.g. a neural network with many parameters and a scalar loss). Forward mode
+  works best on functions with many outputs and few inputs. Since it does not
+  hold on to intermediate activations, it is much more memory efficient than
+  backprop where it is applicable.
+
+  Consider a simple linear regression:
+
+  >>> x = tf.constant([[2.0, 3.0], [1.0, 4.0]])
+  >>> targets = tf.constant([[1.], [-1.]])
+  >>> dense = tf.keras.layers.Dense(1)
+  >>> dense.build([None, 2])
+  >>> with tf.autodiff.ForwardAccumulator(
+  ...    primals=dense.kernel,
+  ...    tangents=tf.constant([[1.], [0.]])) as acc:
+  ...   loss = tf.reduce_sum((dense(x) - targets) ** 2.)
+  >>> acc.jvp(loss)
+  <tf.Tensor: shape=(), dtype=float32, numpy=...>
+
+  The example has two variables containing parameters, `dense.kernel` (2
+  parameters) and `dense.bias` (1 parameter). Considering the training data `x`
+  as a constant, this means the Jacobian matrix for the function mapping from
+  parameters to loss has one row and three columns.
+
+  With forwardprop, we specify a length-three vector in advance which multiplies
+  the Jacobian. The `primals` constructor argument is the parameter (a
+  `tf.Tensor` or `tf.Variable`) we're specifying a vector for, and the
+  `tangents` argument is the "vector" in Jacobian-vector product. If our goal is
+  to compute the entire Jacobian matrix, forwardprop computes one column at a
+  time while backprop computes one row at a time. Since the Jacobian in the
+  linear regression example has only one row, backprop requires fewer
+  invocations:
+
+  >>> x = tf.constant([[2.0, 3.0], [1.0, 4.0]])
+  >>> targets = tf.constant([[1.], [-1.]])
+  >>> dense = tf.keras.layers.Dense(1)
+  >>> dense.build([None, 2])
+  >>> loss_fn = lambda: tf.reduce_sum((dense(x) - targets) ** 2.)
+  >>> kernel_fprop = []
+  >>> with tf.autodiff.ForwardAccumulator(
+  ...     dense.kernel, tf.constant([[1.], [0.]])) as acc:
+  ...   kernel_fprop.append(acc.jvp(loss_fn()))
+  >>> with tf.autodiff.ForwardAccumulator(
+  ...     dense.kernel, tf.constant([[0.], [1.]])) as acc:
+  ...   kernel_fprop.append(acc.jvp(loss_fn()))
+  >>> with tf.autodiff.ForwardAccumulator(dense.bias, tf.constant([1.])) as acc:
+  ...   bias_fprop = acc.jvp(loss_fn())
+  >>> with tf.GradientTape() as tape:
+  ...   loss = loss_fn()
+  >>> kernel_grad, bias_grad = tape.gradient(loss, (dense.kernel, dense.bias))
+  >>> np.testing.assert_allclose(
+  ...     kernel_grad, tf.stack(kernel_fprop)[:, tf.newaxis])
+  >>> np.testing.assert_allclose(bias_grad, bias_fprop[tf.newaxis])
+
+  Implicit in the `tape.gradient` call is a length-one vector which
+  left-multiplies the Jacobian, a vector-Jacobian product.
+
+  `ForwardAccumulator` maintains JVPs corresponding primal tensors it is
+  watching, derived from the original `primals` specified in the constructor. As
+  soon as a primal tensor is deleted, `ForwardAccumulator` deletes the
+  corresponding JVP.
+
+  `acc.jvp(x)` retrieves `acc`'s JVP corresponding to the primal tensor `x`. It
+  does not perform any computation. `acc.jvp` calls can be repeated as long as
+  `acc` is accessible, whether the context manager is active or not. New JVPs
+  are only computed while the context manager is active.
+
+  Note that `ForwardAccumulator`s are always applied in the order their context
+  managers were entered, so inner accumulators will not see JVP computation from
+  outer accumulators. Take higher-order JVPs from outer accumulators:
+
+  >>> primal = tf.constant(1.1)
+  >>> with tf.autodiff.ForwardAccumulator(primal, tf.constant(1.)) as outer:
+  ...   with tf.autodiff.ForwardAccumulator(primal, tf.constant(1.)) as inner:
+  ...     primal_out = primal ** tf.constant(3.5)
+  >>> inner_jvp = inner.jvp(primal_out)
+  >>> inner_jvp  # 3.5 * 1.1 ** 2.5
+  <tf.Tensor: shape=(), dtype=float32, numpy=4.4417057>
+  >>> outer.jvp(inner_jvp)  # 3.5 * 2.5 * 1.1 ** 1.5
+  <tf.Tensor: shape=(), dtype=float32, numpy=10.094786>
+
+  Reversing the collection in the last line to instead retrieve
+  `inner.jvp(outer.jvp(primal_out))` will not work.
+
+  Strict nesting also applies to combinations of `ForwardAccumulator` and
+  `tf.GradientTape`. More deeply nested `GradientTape` objects will ignore the
+  products of outer `ForwardAccumulator` objects. This allows (for example)
+  memory-efficient forward-over-backward computation of Hessian-vector products,
+  where the inner `GradientTape` would otherwise hold on to all intermediate
+  JVPs:
+
+  >>> v = tf.Variable([1., 2.])
+  >>> with tf.autodiff.ForwardAccumulator(
+  ...     v,
+  ...     # The "vector" in Hessian-vector product.
+  ...     tf.constant([1., 0.])) as acc:
+  ...   with tf.GradientTape() as tape:
+  ...     y = tf.reduce_sum(v ** 3.)
+  ...   backward = tape.gradient(y, v)
+  >>> backward  # gradient from backprop
+  <tf.Tensor: shape=(2,), dtype=float32, numpy=array([ 3., 12.], dtype=float32)>
+  >>> acc.jvp(backward)  # forward-over-backward Hessian-vector product
+  <tf.Tensor: shape=(2,), dtype=float32, numpy=array([6., 0.], dtype=float32)>
+  """
+
+  def __init__(self, primals, tangents):
+    """Specify tensors to watch and their Jacobian-vector products.
+
+    Mathematically, `tangents` is a vector right-multiplying the Jacobian matrix
+    (a Jacobian-vector product) for the function computed while this accumulator
+    is active. Since JVPs are computed in forward mode as the computation
+    happens, this vector must be supplied in advance.
+
+    Listing a single tensor multiple times in `primals` raises an
+    exception. Excluding a tensor from `primals` is equivalent to watching it
+    with a tangent tensor of zeros.
+
+    Args:
+      primals: A tensor or nested structure of tensors to watch.
+      tangents: A tensor or nested structure of tensors, with the same nesting
+        structure as `primals`, with each element being a vector with the same
+        size as the corresponding primal element.
+
+    Raises:
+      ValueError: If the same tensor or variable is specified multiple times in
+        `primals`.
+    """
+    self._accumulator = pywrap_tfe.TFE_Py_ForwardAccumulatorNew(False)
+    self._recording = False
+    primal_ids = set()
+    for primal in nest.flatten(primals):
+      if id(primal) in primal_ids:
+        raise ValueError(
+            "Tensor {} was specified as a primal multiple times. This may "
+            "indicate an error. If it was intended, please sum the "
+            "corresponding tangents.")
+      primal_ids.add(id(primal))
+    self._watch(primals, tangents)
+
+  def __enter__(self):
+    self._push_accumulator()
+    return self
+
+  def __exit__(self, typ, value, traceback):
+    if self._recording:
+      self._pop_accumulator()
+
+  def _push_accumulator(self):
+    if self._recording:
+      raise ValueError("Accumulator is already recording.")
+    pywrap_tfe.TFE_Py_ForwardAccumulatorSetAdd(self._accumulator)
+    self._recording = True
+
+  def _pop_accumulator(self):
+    if not self._recording:
+      raise ValueError("Accumulator is not recording.")
+    pywrap_tfe.TFE_Py_ForwardAccumulatorSetRemove(self._accumulator)
+    self._recording = False
+
+  def _watch(self, primals, tangents):
+    """Ensures that `primals` are being traced by this accumulator.
+
+    Mathematically, `tangents` is a vector right-multiplying the Jacobian matrix
+    (a Jacobian-vector product) for the function computed while this accumulator
+    is active. Since JVPs are computed in forward mode as the computation
+    happens, this vector must be supplied in advance.
+
+    Watching a single tensor multiple times sums each of its `tangents`. Any
+    un-watched tensor has zeros for its tangent vector.
+
+    Args:
+      primals: A Tensor or list of Tensors.
+      tangents: A Tensor or list of Tensors matching `primals`.
+    """
+
+    def _watch(primal, tangent):
+      if not primal.dtype.is_floating:
+        logging.log_first_n(
+            logging.WARN, "The dtype of the watched primal must be "
+            "floating (e.g. tf.float32), got %r", 5, primal.dtype)
+      tangent = ops.convert_to_tensor(tangent, dtype=primal.dtype)
+      if hasattr(primal, "handle"):
+        # Run convert_to_tensor to get the captured handle from whichever
+        # function we're running if necessary.
+        primal = ops.convert_to_tensor(primal.handle)
+      pywrap_tfe.TFE_Py_ForwardAccumulatorWatch(self._accumulator, primal,
+                                                tangent)
+
+    nest.map_structure(_watch, primals, tangents)
+
+  def jvp(self, primals, unconnected_gradients=UnconnectedGradients.NONE):
+    """Fetches the Jacobian-vector product computed for `primals`.
+
+    Note that this method performs no computation, and simply looks up a JVP
+    that was already computed (unlike backprop using a `tf.GradientTape`, where
+    the computation happens on the call to `tape.gradient`).
+
+    Args:
+      primals: A watched Tensor or structure of Tensors to fetch the JVPs for.
+      unconnected_gradients: A value which can either hold 'none' or 'zero' and
+        alters the value which will be returned if no JVP was computed for
+        `primals`. The possible values and effects are detailed in
+        'tf.UnconnectedGradients' and it defaults to 'none'.
+
+    Returns:
+      Tensors with the same shapes and dtypes as `primals`, or None if no JVP
+      is available.
+    """
+    unconnected_gradients = UnconnectedGradients(unconnected_gradients)
+    if self._accumulator is None:
+      raise ValueError("Called jvp() without first tracing anything.")
+
+    def _fetch_jvp(tensor):
+      if hasattr(tensor, "handle"):
+        unwrapped_tensor = ops.convert_to_tensor(tensor.handle)
+      else:
+        unwrapped_tensor = tensor
+      result = pywrap_tfe.TFE_Py_ForwardAccumulatorJVP(self._accumulator,
+                                                       unwrapped_tensor)
+      if result is None and unconnected_gradients == UnconnectedGradients.ZERO:
+        result = array_ops.zeros_like(tensor)
+      return result
+
+    return nest.map_structure(_fetch_jvp, primals)
+
+  @classmethod
+  def _batch_accumulator(cls, primals, tangents):
+    """Factory constructor to test accumulator on batches of tangents.
+
+    Args:
+      primals: A tensor or nested structure of tensors to watch.
+      tangents: A tensor or nested structure of tensors, with the same nesting
+        structure as `primals`, with each element being a vector with compatible
+        shape `[None] + primal.shape` of the corresponding primal element.
+
+    Returns:
+      A batch accumulator object.
+    """
+    acc = super(ForwardAccumulator, cls).__new__(cls, primals, tangents)
+    acc._recording = False
+    acc._accumulator = pywrap_tfe.TFE_Py_ForwardAccumulatorNew(True)
+    primal_ids = set()
+    for primal, tangent in zip(nest.flatten(primals), nest.flatten(tangents)):
+      tangent.shape.assert_is_compatible_with(
+          tensor_shape.TensorShape([None]) + primal.shape)
+      if id(primal) in primal_ids:
+        raise ValueError(
+            "Tensor {} was specified as a primal multiple times. This may "
+            "indicate an error. If it was intended, please sum the "
+            "corresponding tangents.")
+      primal_ids.add(id(primal))
+    acc._watch(primals, tangents)
+    return acc

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/forwardprop_util.py

@@ -0,0 +1,74 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for managing forward accumulators.
+
+A separate file from forwardprop.py so that functions can use these utilities.
+"""
+
+import collections
+import contextlib
+
+from tensorflow.python import pywrap_tfe
+
+
+class TangentInfo(
+    collections.namedtuple("TangentInfo", ["indices", "tangents"])):
+  """Packed forward accumulator state. The return value of `pack_tangents`."""
+
+  def __new__(cls, indices=None, tangents=None):
+    if indices is None:
+      indices = ()
+    if tangents is None:
+      tangents = []
+    return super(TangentInfo, cls).__new__(cls, indices, tangents)
+
+
+def pack_tangents(tensors):
+  """Packs forward accumulator state into a TangentInfo tuple.
+
+  Args:
+    tensors: A flat list of Tensors to pack forward accumulator state for.
+
+  Returns:
+    A tuple of (indices, tangents):
+      indices: A sequence of sequences of two-element tuples. Each forward
+        accumulator is represented as a sequence of tuples with (primal_index,
+        jvp_index). Both integers index into the concatenated `tensors + jvps`
+        array.
+      tangents: A flat list of Tensors. Best interpreted as a sequence to be
+        appended to `tensors`.
+  """
+  return TangentInfo(*pywrap_tfe.TFE_Py_PackJVPs(tensors))
+
+
+@contextlib.contextmanager
+def push_forwardprop_state():
+  """Temporarily push or pop transient state for accumulators in the active set.
+
+  Allows an accumulator which is currently processing an operation to
+  temporarily reset its state. This is useful when building forwardprop versions
+  of functions, where an accumulator will trigger function building and then
+  must process captured symbolic tensors while building it. Without pushing and
+  popping, accumulators ignore operations executed as a direct result of their
+  own jvp computations.
+
+  Yields:
+    None (used for its side effect).
+  """
+  try:
+    pywrap_tfe.TFE_Py_ForwardAccumulatorPushState()
+    yield
+  finally:
+    pywrap_tfe.TFE_Py_ForwardAccumulatorPopState()

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/function.py

@@ -0,0 +1,37 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Supports old symbols supplied by this file while the code is refactored."""
+
+# pylint:disable=unused-import,g-bad-import-order
+
+# TODO(b/243822285): Reduce this list as much as possible.
+# Constants
+from tensorflow.python.eager.polymorphic_function.concrete_function import _BACKWARD_PREFIX
+from tensorflow.python.eager.polymorphic_function.concrete_function import _FORWARD_PREFIX
+from tensorflow.python.eager.polymorphic_function.concrete_function import _INFERENCE_PREFIX
+
+# Function Classes
+from tensorflow.python.eager.polymorphic_function.concrete_function import ConcreteFunction
+from tensorflow.python.eager.polymorphic_function.atomic_function import from_func_graph
+from tensorflow.python.eager.polymorphic_function.atomic_function import AtomicFunction
+
+# Utilities
+from tensorflow.python.eager.polymorphic_function.tf_method_target import TfMethodTarget
+from tensorflow.python.eager.polymorphic_function.concrete_function import _inference_name
+
+# TODO(b/244360504): Remove in favor of graph transformation API.
+# QUARANTINED - Function Callback Modification API
+from tensorflow.python.eager.polymorphic_function.transform import FUNC_GRAPH_TRANSFORMS
+from tensorflow.python.eager.polymorphic_function.transform import CONCRETE_FUNCTION_CALLBACKS

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/graph_only_ops.py

@@ -0,0 +1,46 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Graph-only versions of a few op functions, for internal use only."""
+
+# Must be separate from array_ops to avoid a cyclic dependency.
+
+from tensorflow.core.framework import attr_value_pb2
+from tensorflow.python.framework import op_callbacks
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_shape
+
+
+def graph_placeholder(dtype, shape, name=None):
+  """Graph-only version of tf.compat.v1.placeholder(), for internal use only."""
+  dtype = dtype.base_dtype
+  dtype_value = attr_value_pb2.AttrValue(type=dtype.as_datatype_enum)
+  if isinstance(shape, (list, tuple)):
+    shape = tensor_shape.TensorShape(shape)
+  shape = attr_value_pb2.AttrValue(shape=shape.as_proto())
+  g = ops.get_default_graph()
+  attrs = {"dtype": dtype_value, "shape": shape}
+  op = g._create_op_internal(  # pylint: disable=protected-access
+      "Placeholder", [], [dtype], input_types=[],
+      attrs=attrs, name=name)
+  result, = op.outputs
+  if op_callbacks.should_invoke_op_callbacks():
+    # TODO(b/147670703): Once the special-op creation code paths
+    # are unified. Remove this `if` block.
+    callback_outputs = op_callbacks.invoke_op_callbacks(
+        "Placeholder", tuple(), attrs, tuple(op.outputs),
+        op_name=name, graph=g)
+    if callback_outputs is not None:
+      result, = callback_outputs
+  return result

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/imperative_grad.py

@@ -0,0 +1,73 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Code for backpropagation using the tape utilities."""
+
+import collections
+
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.ops.unconnected_gradients import UnconnectedGradients
+from tensorflow.python.util import compat
+
+VSpace = collections.namedtuple("VSpace", [
+    "aggregate_fn", "num_elements_fn", "zeros_fn", "ones_fn",
+    "zeros_like_fn", "ones_like_fn", "graph_shape_fn"
+])
+
+
+def imperative_grad(tape,
+                    target,
+                    sources,
+                    output_gradients=None,
+                    sources_raw=None,
+                    unconnected_gradients=UnconnectedGradients.NONE):
+  """Computes gradients from the imperatively defined tape on top of the stack.
+
+  Works by filtering the tape, computing how many downstream usages are of each
+  tensor and entry, and repeatedly applying backward functions until we have
+  gradients for all sources.
+
+  Args:
+   tape: the gradient tape which stores the trace.
+   target: either a Tensor or list of Tensors to be differentiated.
+   sources: list of Tensors for which we want gradients
+   output_gradients: if not None, a list of gradient provided for each Target,
+    or None if we are to use the target's computed downstream gradient.
+   sources_raw: if not None, a list of the source python objects from which the
+    sources were generated. Should have the same length as sources. Only needs
+    to be populated if unconnected_gradients is 'zero'.
+   unconnected_gradients: determines the value returned if the target and
+    sources are unconnected. When 'none' the value returned is None wheras when
+    'zero' a zero tensor in the same shape as the sources is returned.
+
+  Returns:
+   the gradient wrt each of the sources.
+
+  Raises:
+    ValueError: if the arguments are invalid.
+    RuntimeError: if something goes wrong.
+  """
+  try:
+    unconnected_gradients = UnconnectedGradients(unconnected_gradients)
+  except ValueError:
+    raise ValueError(
+        "Unknown value for unconnected_gradients: %r" % unconnected_gradients)
+
+  return pywrap_tfe.TFE_Py_TapeGradient(
+      tape._tape,  # pylint: disable=protected-access
+      target,
+      sources,
+      output_gradients,
+      sources_raw,
+      compat.as_str(unconnected_gradients.value))

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/lift_to_graph.py

@@ -0,0 +1,365 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+# pylint: disable=unidiomatic-typecheck
+"""Utility to lift subgraphs."""
+
+import collections
+
+from tensorflow.python.framework import func_graph
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor as tensor_lib
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import op_selector
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.util import compat
+from tensorflow.python.util import object_identity
+from tensorflow.python.util.tf_export import tf_export
+
+
+UnliftableError = op_selector.UnliftableError
+
+
+def _as_operation(op_or_tensor):
+  if isinstance(op_or_tensor, tensor_lib.Tensor):
+    return op_or_tensor.op
+  return op_or_tensor
+
+
+def _constant_inputs(op_or_tensor):
+  return all(_as_operation(i).type == u"Const"
+             and not _as_operation(i).control_inputs
+             for i in op_selector.graph_inputs(_as_operation(op_or_tensor)))
+
+
+# Represents an input to `copied_op` which must be updated once
+# `old_graph_tensor` has been copied.
+_InputMutation = collections.namedtuple(
+    "_InputMutation",
+    ["copied_op", "input_index", "old_graph_tensor"])
+
+
+# Represents a control input to `copied_op` which must be added once
+# `old_graph_op` has been copied.
+_ControlMutation = collections.namedtuple(
+    "_ControlMutation",
+    ["copied_op", "old_graph_op"])
+
+
+def _copy_non_source(op, graph, op_map, base_graph):
+  """Copy an op directly to a given graph.
+
+  Generally `op`'s inputs should already have been copied. If this is not the
+  case, for example with v1 while_loops, then `_copy_non_source` inserts
+  placeholders for the unavailable Tensors and returns a list of required
+  mutations.
+
+  Args:
+    op: The op to be copied.
+    graph: The destination graph.
+    op_map: A dict mapping ops and tensors in the old graph to the new one.
+    base_graph: The graph we're copying from, for any necessary functions.
+  Returns:
+    A tuple of (required_inputs, required_control_inputs):
+      required_inputs:
+        A list of `_InputMutation` tuples containing inputs to `copied_op` which
+        must be updated once `old_graph_tensor` has been copied.
+      required_control_inputs:
+        A list of `_ControlMutation` tuples containing control inputs to
+        `copied_op` which must be added once `old_graph_op` has been copied.
+  """
+  input_mutations = []
+  control_mutations = []
+  copied_inputs = []
+  for input_index, original_input in enumerate(op.inputs):
+    copied_input = op_map.get(original_input, None)
+    if copied_input is None:
+      # An input for this op is missing due to a loop in the graph. We'll insert
+      # a placeholder for now and return information about the required post-hoc
+      # mutation.
+      copied_input = array_ops.placeholder(
+          name="unused_control_flow_input",
+          shape=original_input.shape,
+          dtype=original_input.dtype)
+      input_mutations.append(
+          # `copied_op` is filled in below, after we've created it.
+          _InputMutation(copied_op=None,
+                         input_index=input_index,
+                         old_graph_tensor=original_input))
+    copied_inputs.append(copied_input)
+
+  copied_control_inputs = []
+  for original_control_input in op.control_inputs:
+    copied_control_input = op_map.get(original_control_input, None)
+    if copied_control_input is None:
+      control_mutations.append(
+          _ControlMutation(copied_op=None,
+                           old_graph_op=original_control_input))
+    else:
+      copied_control_inputs.append(copied_control_input)
+
+  # Don't copy over nodes with _tpu_replicate attribute. This attributed is used
+  # to signal that the op was built inside a tpu_replicate context; if we're
+  # lifting it to another graph we're similarly lifting it into another context.
+  with ops.control_dependencies(copied_control_inputs), ops.device(op.device):
+    # pylint: disable=protected-access
+    f = base_graph._functions.get(op.type, None)
+    if f is not None and compat.as_str(f.name) not in graph._functions:
+      f.add_to_graph(graph)
+    # pylint: enable=protected-access
+
+    # Create a new op in the destination graph if it doesn't exist before.
+    copied_op = graph.create_op(
+        op_type=op.type,
+        inputs=copied_inputs,
+        dtypes=[x.dtype for x in op.outputs],
+        attrs={
+            key: value for key, value in op.node_def.attr.items()
+            if not key.startswith("_class") and
+            not key.startswith("_tpu_replicate")
+        },  # b/128981532.
+        name=op.name)
+  op_map[op] = copied_op
+  for i, o in enumerate(op.outputs):
+    op_map[o] = copied_op.outputs[i]
+
+  return ([mutation._replace(copied_op=copied_op)
+           for mutation in input_mutations],
+          [mutation._replace(copied_op=copied_op)
+           for mutation in control_mutations])
+
+
+def _copy_source(s, graph, op_map, handle_captures, inverse_captures,
+                 base_graph):
+  """Create a source in a graph based on a Tensor from a different graph.
+
+  This function creates a placeholder analog of `s` in a graph with the
+  following behavior:
+
+  1) If s is a captured Tensor or Variable and handle_captures is set to True,
+     simply capture it in the new graph as well.
+
+  2) If s is a PlaceholderWithDefault whose default is a constant, preserve
+     said default in the new graph.
+
+  3) When applicable, copy resource variable metadata from `s` to the newly
+     created placeholder.
+
+  Args:
+    s: The source of interest.
+    graph: The destination graph.
+    op_map: A dict mapping ops and tensors in the old graph to the new one.
+    handle_captures: A boolean indicating whether to re-capture s in the new
+      graph or simply create a vanilla placeholder.
+    inverse_captures: A dict mapping s back to the Tensor or Variable that it
+      captures.
+    base_graph: The graph being copied from.
+  """
+  if handle_captures and s in inverse_captures:
+    copied_placeholder = graph.capture(inverse_captures[s], name=s.op.name)
+  elif s.op.type == "PlaceholderWithDefault" and _constant_inputs(s):
+    # Copy the default value to the graph.
+    default_value = s.op.inputs[0]
+    unavailable_inputs, unavailable_control_inputs = _copy_non_source(
+        op=default_value.op, graph=graph, op_map=op_map,
+        base_graph=base_graph)
+    if unavailable_inputs or unavailable_control_inputs:
+      raise AssertionError(
+          "Could not copy source node {} because it has inputs."
+          .format(default_value))
+
+    with ops.device(s.op.device):
+      copied_placeholder = array_ops.placeholder_with_default(
+          input=op_map[default_value], shape=s.shape, name=s.op.name)
+  else:
+    with ops.device(s.op.device):
+      copied_placeholder = array_ops.placeholder(
+          dtype=s.dtype, shape=s.shape, name=s.op.name)
+
+  base_handle = resource_variable_ops.get_resource_handle_data(s)
+  if base_handle.shape_and_type:
+    resource_variable_ops._set_handle_shapes_and_types(  # pylint: disable=protected-access
+        copied_placeholder,
+        base_handle,
+        graph_mode=True)
+
+  op_map[s] = copied_placeholder
+  # Add an entry for the op of the source tensor so that if there are any nodes
+  # depending on that op via control dependencies it can work correctly.
+  op_map[s.op] = copied_placeholder.op
+
+
+@tf_export("__internal__.lift_to_graph", v1=[])
+def lift_to_graph(tensors,
+                  graph,
+                  sources=None,
+                  disallowed_placeholders=None,
+                  add_sources=False,
+                  handle_captures=False,
+                  base_graph=None,
+                  op_map=None):
+  """Copies the tensor and all its inputs recursively to the outer graph.
+
+  Args:
+    tensors: The Tensors to lift.
+    graph: The graph to lift to.
+    sources: Optional sequence of nodes to start from. If omitted the whole
+      subgraph which feeds into `init_tensor` is lifted.
+    disallowed_placeholders: An optional set of ops which may not appear in the
+      lifted graph. Defaults to all placeholders.
+    add_sources: A boolean indicating whether placeholders which are not in
+      sources should be allowed.
+    handle_captures: A boolean indicating whether to re-capture s in the new
+      graph or simply create a vanilla placeholder.
+    base_graph: The graph from which to lift ops. This will be inferred if not
+      specified.
+    op_map: A map contains all the existing nodes that have been lifted to the
+      destination graph, so they won't be lifted and copied again.
+
+  Returns:
+    A mapping from ops in the current default graph to ops in `graph`.
+
+  Raises:
+    UnliftableError: If a placeholder blocks lifting.
+  """
+  variable_init_tensors = []
+  init_tensors = []
+  for tensor in tensors:
+    if isinstance(tensor, resource_variable_ops.ResourceVariable):
+      variable_init_tensors.append(tensor)
+    else:
+      init_tensors.append(tensor)
+  base_graph = base_graph or init_tensors[0].graph
+  op_map = op_map or object_identity.ObjectIdentityDictionary()
+
+  # Check that the initializer does not depend on any placeholders.
+  sources = object_identity.ObjectIdentitySet(sources or [])
+  visited_ops = set(x.op for x in sources)
+  op_outputs = collections.defaultdict(set)
+
+  # First we extract the subgraph between init_tensors and sources.
+  for init_tensor in init_tensors:
+    sources.update(op_selector.map_subgraph(
+        init_tensor=init_tensor,
+        sources=sources,
+        disallowed_placeholders=disallowed_placeholders,
+        visited_ops=visited_ops,
+        op_outputs=op_outputs,
+        add_sources=add_sources))
+
+  # Try to topologically sort the nodes we've extracted. Now we know how many of
+  # their outputs are part of this subgraph.
+  ops_to_copy = []
+  marked_ops = set([])
+  ops_to_visit = [_as_operation(t) for t in init_tensors
+                  if not op_outputs[_as_operation(t)]]
+  unvisited_ops = set(ops_to_visit)
+  while unvisited_ops:
+    while ops_to_visit:
+      op = ops_to_visit.pop()
+      if op in marked_ops:
+        continue
+      marked_ops.add(op)
+      ops_to_copy.append(op)
+      for inp in op_selector.graph_inputs(op):
+        # Don't lift the TPUReplicateMetadata nodes out of the function, because
+        # it has no registered kernels.
+        if inp.type == "TPUReplicateMetadata":
+          continue
+        unvisited_ops.add(inp)
+        if (all(x in marked_ops for x in op_outputs[inp]) and
+            inp not in sources):
+          ops_to_visit.append(inp)
+    unvisited_ops.difference_update(marked_ops)
+    if unvisited_ops:
+      # `unvisited_ops` should only have elements if the graph has a loop. In
+      # this case we want to keep copying and there's no topological ordering;
+      # we'll do ugly post-hoc mutations instead.
+      ops_to_visit.append(next(iter(unvisited_ops)))
+
+  # When the topological sort fails due to loops, it can result in exceptions
+  # later when copying a node which inputs haven't been copied yet. We can
+  # improve that pseudo-topological order slightly by putting the ops without
+  # inputs, such as constants, at the start of the topological order (i.e at
+  # the end of ops_to_copy).
+  ops_to_copy.sort(key=(lambda op: len(op_selector.graph_inputs(op)) == 0))
+
+  # When lifting from one FuncGraph to another, we will need to capture the
+  # relevant tensors as well.
+  captures = []
+  inverse_captures = object_identity.ObjectIdentityDictionary()
+  internal_captures = []
+  if (isinstance(base_graph, func_graph.FuncGraph) and
+      isinstance(graph, func_graph.FuncGraph)):
+    captures = base_graph.captures
+    for external_capture, internal_capture in captures:
+      inverse_captures[internal_capture] = external_capture
+    internal_captures = base_graph.internal_captures
+
+  # ops_to_copy now holds a reverse topologically sorted list of ops which
+  # ends in the initializer. We copy those to the outermost graph and
+  # build the initialization op there.
+  with graph.as_default():
+    for i in variable_init_tensors:
+      op_map[i] = i
+    source_ops = set()
+    # Add the sources in the same order as the original graph.
+    for s in internal_captures:
+      if s in sources:
+        sources.remove(s)
+        source_ops.add(s.op)
+        _copy_source(
+            s=s,
+            graph=graph,
+            op_map=op_map,
+            handle_captures=handle_captures,
+            inverse_captures=inverse_captures,
+            base_graph=base_graph)
+    for s in sources:
+      source_ops.add(s.op)
+      _copy_source(
+          s=s,
+          graph=graph,
+          op_map=op_map,
+          handle_captures=handle_captures,
+          inverse_captures=inverse_captures,
+          base_graph=base_graph)
+
+    input_mutations = []
+    control_mutations = []
+    for op in reversed(ops_to_copy):
+      if op in source_ops or op in op_map:
+        continue
+      new_input_mutations, new_control_mutations = _copy_non_source(
+          op=op, graph=graph, op_map=op_map, base_graph=base_graph)
+      input_mutations.extend(new_input_mutations)
+      control_mutations.extend(new_control_mutations)
+
+    # Mutate the new graph to insert any loops which existed in the source
+    # graph due to v1 while_loops.
+    #
+    # pylint: disable=protected-access
+    with graph._mutation_lock():
+      for mutation in input_mutations:
+        mutation.copied_op._update_input(
+            mutation.input_index, op_map[mutation.old_graph_tensor])
+      for mutation in control_mutations:
+        # Don't lift the TPUReplicateMetadata nodes out of the function, because
+        # it has no registered kernels.
+        if mutation.old_graph_op.type == "TPUReplicateMetadata":
+          continue
+        mutation.copied_op._add_control_input(op_map[mutation.old_graph_op])
+    # pylint: enable=protected-access
+
+    return op_map

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/memory_tests/memory_test_util.py

@@ -0,0 +1,73 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utils for memory tests."""
+
+import collections
+import gc
+import time
+
+from tensorflow.python.eager import context
+
+# memory_profiler might not be available in the OSS version of TensorFlow.
+try:
+  import memory_profiler  # pylint:disable=g-import-not-at-top
+except ImportError:
+  memory_profiler = None
+
+
+def _instance_count_by_class():
+  counter = collections.Counter()
+
+  for obj in gc.get_objects():
+    try:
+      counter[obj.__class__.__name__] += 1
+    except Exception:  # pylint:disable=broad-except
+      pass
+
+  return counter
+
+
+def assert_no_leak(f, num_iters=100000, increase_threshold_absolute_mb=25):
+  """Assert memory usage doesn't increase beyond given threshold for f."""
+
+  with context.eager_mode():
+    # Warm up.
+    f()
+
+    # Wait for background threads to start up and take over memory.
+    # FIXME: The nature of this test leaves few other options. Maybe there
+    # is a better way to do this.
+    time.sleep(4)
+
+    gc.collect()
+    initial = memory_profiler.memory_usage(-1)[0]
+    instance_count_by_class_before = _instance_count_by_class()
+
+    for _ in range(num_iters):
+      f()
+
+    gc.collect()
+    increase = memory_profiler.memory_usage(-1)[0] - initial
+
+    assert increase < increase_threshold_absolute_mb, (
+        "Increase is too high. Initial memory usage: %f MB. Increase: %f MB. "
+        "Maximum allowed increase: %f MB. "
+        "Instance count diff before/after: %s") % (
+            initial, increase, increase_threshold_absolute_mb,
+            _instance_count_by_class() - instance_count_by_class_before)
+
+
+def memory_profiler_is_available():
+  return memory_profiler is not None

videochat2/lib/python3.10/site-packages/tensorflow/python/eager/monitoring.py

@@ -0,0 +1,542 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""TensorFlow monitoring APIs."""
+
+import collections
+import functools
+import time
+
+from tensorflow.core.framework import summary_pb2
+from tensorflow.python import pywrap_tfe
+from tensorflow.python.client import pywrap_tf_session
+from tensorflow.python.framework import c_api_util
+from tensorflow.python.util import compat
+from tensorflow.python.util.tf_export import tf_export
+
+_MetricMethod = collections.namedtuple('MetricMethod', 'create delete get_cell')
+_counter_methods = [
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewCounter0,
+        delete=pywrap_tfe.TFE_MonitoringDeleteCounter0,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellCounter0),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewCounter1,
+        delete=pywrap_tfe.TFE_MonitoringDeleteCounter1,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellCounter1),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewCounter2,
+        delete=pywrap_tfe.TFE_MonitoringDeleteCounter2,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellCounter2),
+]
+_int_gauge_methods = [
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewIntGauge0,
+        delete=pywrap_tfe.TFE_MonitoringDeleteIntGauge0,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellIntGauge0),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewIntGauge1,
+        delete=pywrap_tfe.TFE_MonitoringDeleteIntGauge1,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellIntGauge1),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewIntGauge2,
+        delete=pywrap_tfe.TFE_MonitoringDeleteIntGauge2,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellIntGauge2),
+]
+_string_gauge_methods = [
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewStringGauge0,
+        delete=pywrap_tfe.TFE_MonitoringDeleteStringGauge0,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellStringGauge0),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewStringGauge1,
+        delete=pywrap_tfe.TFE_MonitoringDeleteStringGauge1,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellStringGauge1),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewStringGauge2,
+        delete=pywrap_tfe.TFE_MonitoringDeleteStringGauge2,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellStringGauge2),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewStringGauge3,
+        delete=pywrap_tfe.TFE_MonitoringDeleteStringGauge3,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellStringGauge3),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewStringGauge4,
+        delete=pywrap_tfe.TFE_MonitoringDeleteStringGauge4,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellStringGauge4),
+]
+_bool_gauge_methods = [
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewBoolGauge0,
+        delete=pywrap_tfe.TFE_MonitoringDeleteBoolGauge0,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellBoolGauge0),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewBoolGauge1,
+        delete=pywrap_tfe.TFE_MonitoringDeleteBoolGauge1,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellBoolGauge1),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewBoolGauge2,
+        delete=pywrap_tfe.TFE_MonitoringDeleteBoolGauge2,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellBoolGauge2),
+]
+_sampler_methods = [
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewSampler0,
+        delete=pywrap_tfe.TFE_MonitoringDeleteSampler0,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellSampler0),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewSampler1,
+        delete=pywrap_tfe.TFE_MonitoringDeleteSampler1,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellSampler1),
+    _MetricMethod(
+        create=pywrap_tfe.TFE_MonitoringNewSampler2,
+        delete=pywrap_tfe.TFE_MonitoringDeleteSampler2,
+        get_cell=pywrap_tfe.TFE_MonitoringGetCellSampler2),
+]
+
+
+class Metric(object):
+  """The base class of metric."""
+
+  __slots__ = ["_metric", "_metric_name", "_metric_methods", "_label_length"]
+
+  def __init__(self, metric_name, metric_methods, label_length, *args):
+    """Creates a new metric.
+
+    Args:
+      metric_name: name of the metric class.
+      metric_methods: list of swig metric methods.
+      label_length: length of label args.
+      *args: the arguments to call create method.
+    """
+    self._metric_name = metric_name
+    self._metric_methods = metric_methods
+    self._label_length = label_length
+
+    if label_length >= len(self._metric_methods):
+      raise ValueError('Cannot create {} metric with label >= {}'.format(
+          self._metric_name, len(self._metric_methods)))
+
+    self._metric = self._metric_methods[self._label_length].create(*args)
+
+  def __del__(self):
+    try:
+      deleter = self._metric_methods[self._label_length].delete
+      metric = self._metric
+    except AttributeError:
+      return
+
+    if deleter is not None:
+      deleter(metric)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    if len(labels) != self._label_length:
+      raise ValueError('The {} expects taking {} labels'.format(
+          self._metric_name, self._label_length))
+    return self._metric_methods[self._label_length].get_cell(
+        self._metric, *labels)
+
+
+class CounterCell(object):
+  """CounterCell stores each value of a Counter."""
+
+  __slots__ = ["_cell"]
+
+  def __init__(self, cell):
+    """Creates a new CounterCell.
+
+    Args:
+      cell: A c pointer of TFE_MonitoringCounterCell.
+    """
+    self._cell = cell
+
+  def increase_by(self, value):
+    """Atomically increments the value.
+
+    Args:
+      value: non-negative value.
+    """
+    pywrap_tfe.TFE_MonitoringCounterCellIncrementBy(self._cell, value)
+
+  def value(self):
+    """Retrieves the current value."""
+    return pywrap_tfe.TFE_MonitoringCounterCellValue(self._cell)
+
+
+class Counter(Metric):
+  """A stateful class for updating a cumulative integer metric.
+
+  This class encapsulates a set of values (or a single value for a label-less
+  metric). Each value is identified by a tuple of labels. The class allows the
+  user to increment each value.
+  """
+
+  __slots__ = []
+
+  def __init__(self, name, description, *labels):
+    """Creates a new Counter.
+
+    Args:
+      name: name of the new metric.
+      description: description of the new metric.
+      *labels: The label list of the new metric.
+    """
+    super(Counter, self).__init__('Counter', _counter_methods, len(labels),
+                                  name, description, *labels)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    return CounterCell(super(Counter, self).get_cell(*labels))
+
+
+class IntGaugeCell(object):
+  """A single integer value stored in an `IntGauge`."""
+
+  __slots__ = ["_cell"]
+
+  def __init__(self, cell):
+    """Creates a new IntGaugeCell.
+
+    Args:
+      cell: A c pointer of TFE_MonitoringIntGaugeCell.
+    """
+    self._cell = cell
+
+  def set(self, value):
+    """Atomically set the value.
+
+    Args:
+      value: integer value.
+    """
+    pywrap_tfe.TFE_MonitoringIntGaugeCellSet(self._cell, value)
+
+  def value(self):
+    """Retrieves the current value."""
+    return pywrap_tfe.TFE_MonitoringIntGaugeCellValue(self._cell)
+
+
+class IntGauge(Metric):
+  """A stateful class for updating a gauge-like integer metric.
+
+  This class encapsulates a set of integer values (or a single value for a
+  label-less metric). Each value is identified by a tuple of labels. The class
+  allows the user to set each value.
+  """
+
+  __slots__ = []
+
+  def __init__(self, name, description, *labels):
+    """Creates a new IntGauge.
+
+    Args:
+      name: name of the new metric.
+      description: description of the new metric.
+      *labels: The label list of the new metric.
+    """
+    super(IntGauge, self).__init__('IntGauge', _int_gauge_methods, len(labels),
+                                   name, description, *labels)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    return IntGaugeCell(super(IntGauge, self).get_cell(*labels))
+
+
+class StringGaugeCell(object):
+  """A single string value stored in an `StringGauge`."""
+
+  __slots__ = ["_cell"]
+
+  def __init__(self, cell):
+    """Creates a new StringGaugeCell.
+
+    Args:
+      cell: A c pointer of TFE_MonitoringStringGaugeCell.
+    """
+    self._cell = cell
+
+  def set(self, value):
+    """Atomically set the value.
+
+    Args:
+      value: string value.
+    """
+    pywrap_tfe.TFE_MonitoringStringGaugeCellSet(self._cell, value)
+
+  def value(self):
+    """Retrieves the current value."""
+    with c_api_util.tf_buffer() as buffer_:
+      pywrap_tfe.TFE_MonitoringStringGaugeCellValue(self._cell, buffer_)
+      value = pywrap_tf_session.TF_GetBuffer(buffer_).decode('utf-8')
+    return value
+
+
+class StringGauge(Metric):
+  """A stateful class for updating a gauge-like string metric.
+
+  This class encapsulates a set of string values (or a single value for a
+  label-less metric). Each value is identified by a tuple of labels. The class
+  allows the user to set each value.
+  """
+
+  __slots__ = []
+
+  def __init__(self, name, description, *labels):
+    """Creates a new StringGauge.
+
+    Args:
+      name: name of the new metric.
+      description: description of the new metric.
+      *labels: The label list of the new metric.
+    """
+    super(StringGauge, self).__init__('StringGauge', _string_gauge_methods,
+                                      len(labels), name, description, *labels)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    return StringGaugeCell(super(StringGauge, self).get_cell(*labels))
+
+
+class BoolGaugeCell(object):
+  """A single boolean value stored in an `BoolGauge`."""
+
+  __slots__ = ["_cell"]
+
+  def __init__(self, cell):
+    """Creates a new BoolGaugeCell.
+
+    Args:
+      cell: A c pointer of TFE_MonitoringBoolGaugeCell.
+    """
+    self._cell = cell
+
+  def set(self, value):
+    """Atomically set the value.
+
+    Args:
+      value: bool value.
+    """
+    pywrap_tfe.TFE_MonitoringBoolGaugeCellSet(self._cell, value)
+
+  def value(self):
+    """Retrieves the current value."""
+    return pywrap_tfe.TFE_MonitoringBoolGaugeCellValue(self._cell)
+
+
+@tf_export("__internal__.monitoring.BoolGauge", v1=[])
+class BoolGauge(Metric):
+  """A stateful class for updating a gauge-like bool metric.
+
+  This class encapsulates a set of boolean values (or a single value for a
+  label-less metric). Each value is identified by a tuple of labels. The class
+  allows the user to set each value.
+  """
+
+  __slots__ = []
+
+  def __init__(self, name, description, *labels):
+    """Creates a new BoolGauge.
+
+    Args:
+      name: name of the new metric.
+      description: description of the new metric.
+      *labels: The label list of the new metric.
+    """
+    super(BoolGauge, self).__init__('BoolGauge', _bool_gauge_methods,
+                                    len(labels), name, description, *labels)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    return BoolGaugeCell(super(BoolGauge, self).get_cell(*labels))
+
+
+class SamplerCell(object):
+  """SamplerCell stores each value of a Sampler."""
+
+  __slots__ = ["_cell"]
+
+  def __init__(self, cell):
+    """Creates a new SamplerCell.
+
+    Args:
+      cell: A c pointer of TFE_MonitoringSamplerCell.
+    """
+    self._cell = cell
+
+  def add(self, value):
+    """Atomically add a sample.
+
+    Args:
+      value: float value.
+    """
+    pywrap_tfe.TFE_MonitoringSamplerCellAdd(self._cell, value)
+
+  def value(self):
+    """Retrieves the current distribution of samples.
+
+    Returns:
+      A HistogramProto describing the distribution of samples.
+    """
+    with c_api_util.tf_buffer() as buffer_:
+      pywrap_tfe.TFE_MonitoringSamplerCellValue(self._cell, buffer_)
+      proto_data = pywrap_tf_session.TF_GetBuffer(buffer_)
+    histogram_proto = summary_pb2.HistogramProto()
+    histogram_proto.ParseFromString(compat.as_bytes(proto_data))
+    return histogram_proto
+
+
+class Buckets(object):
+  """Bucketing strategies for the samplers."""
+
+  __slots__ = ["buckets"]
+
+  def __init__(self, buckets):
+    """Creates a new Buckets.
+
+    Args:
+      buckets: A c pointer of TFE_MonitoringBuckets.
+    """
+    self.buckets = buckets
+
+  def __del__(self):
+    pywrap_tfe.TFE_MonitoringDeleteBuckets(self.buckets)
+
+
+class ExponentialBuckets(Buckets):
+  """Exponential bucketing strategy.
+
+  Sets up buckets of the form:
+      [-DBL_MAX, ..., scale * growth^i,
+       scale * growth_factor^(i + 1), ..., DBL_MAX].
+  """
+
+  __slots__ = []
+
+  def __init__(self, scale, growth_factor, bucket_count):
+    """Creates a new exponential Buckets.
+
+    Args:
+      scale: float
+      growth_factor: float
+      bucket_count: integer
+    """
+    super(ExponentialBuckets, self).__init__(
+        pywrap_tfe.TFE_MonitoringNewExponentialBuckets(scale, growth_factor,
+                                                       bucket_count))
+
+
+class Sampler(Metric):
+  """A stateful class for updating a cumulative histogram metric.
+
+  This class encapsulates a set of histograms (or a single histogram for a
+  label-less metric) configured with a list of increasing bucket boundaries.
+  Each histogram is identified by a tuple of labels. The class allows the
+  user to add a sample to each histogram value.
+  """
+
+  __slots__ = []
+
+  def __init__(self, name, buckets, description, *labels):
+    """Creates a new Sampler.
+
+    Args:
+      name: name of the new metric.
+      buckets: bucketing strategy of the new metric.
+      description: description of the new metric.
+      *labels: The label list of the new metric.
+    """
+    super(Sampler, self).__init__('Sampler', _sampler_methods, len(labels),
+                                  name, buckets.buckets, description, *labels)
+
+  def get_cell(self, *labels):
+    """Retrieves the cell."""
+    return SamplerCell(super(Sampler, self).get_cell(*labels))
+
+
+# Keeping track of current MonitoredTimer sections to prevent repetitive
+# counting.
+MonitoredTimerSections = []
+
+
+class MonitoredTimer(object):
+  """A context manager to measure the walltime and increment a Counter cell."""
+
+  __slots__ = [
+      "cell",
+      "t",
+      "monitored_section_name",
+      "_counting",
+      "_avoid_repetitive_counting",
+  ]
+
+  def __init__(
+      self, cell, monitored_section_name=None, avoid_repetitive_counting=False
+  ):
+    """Creates a new MonitoredTimer.
+
+    Args:
+      cell: the cell associated with the time metric that will be inremented.
+      monitored_section_name: name of action being monitored here.
+      avoid_repetitive_counting: when set to True, if already in a monitored
+        timer section with the same monitored_section_name, skip counting.
+    """
+    self.cell = cell
+    self.monitored_section_name = monitored_section_name
+    self._avoid_repetitive_counting = avoid_repetitive_counting
+    self._counting = True
+
+  def __enter__(self):
+    if (
+        self._avoid_repetitive_counting
+        and self.monitored_section_name
+        and self.monitored_section_name in MonitoredTimerSections
+    ):
+      self._counting = False
+      return self
+
+    self.t = time.time()
+    if self.monitored_section_name:
+      MonitoredTimerSections.append(self.monitored_section_name)
+
+    return self
+
+  def __exit__(self, exception_type, exception_value, traceback):
+    del exception_type, exception_value, traceback
+    if self._counting:
+      micro_seconds = (time.time() - self.t) * 1000000
+      self.cell.increase_by(int(micro_seconds))
+      if self.monitored_section_name:
+        MonitoredTimerSections.remove(self.monitored_section_name)
+
+
+def monitored_timer(cell):
+  """A function decorator for adding MonitoredTimer support.
+
+  Args:
+    cell: the cell associated with the time metric that will be inremented.
+  Returns:
+    A decorator that measure the function runtime and increment the specified
+    counter cell.
+  """
+
+  def actual_decorator(func):
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      with MonitoredTimer(cell):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+  return actual_decorator