Add files using upload-large-folder tool

.gitattributes

@@ -882,3 +882,7 @@ videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_tr
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/nn_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/ragged/__pycache__/ragged_tensor.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_nn_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/metrics_impl.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/ops/parallel_for/__pycache__/pfor.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/lib/io/_pywrap_record_io.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/lib/core/_pywrap_py_func.so filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/data_service_ops.py

@@ -0,0 +1,1176 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python API for executing a tf.data.Dataset using a tf.data service."""
+
+import enum
+import functools
+from typing import Callable
+
+from tensorflow.core.protobuf import data_service_pb2
+from tensorflow.python import tf2
+from tensorflow.python.data.experimental.ops import compression_ops
+from tensorflow.python.data.experimental.service import _pywrap_server_lib
+from tensorflow.python.data.experimental.service import _pywrap_utils
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import options as options_lib
+from tensorflow.python.data.ops import structured_function
+from tensorflow.python.data.ops.options import AutoShardPolicy
+from tensorflow.python.data.ops.options import ExternalStatePolicy
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import gen_experimental_dataset_ops
+from tensorflow.python.ops import string_ops
+from tensorflow.python.saved_model import nested_structure_coder
+from tensorflow.python.util.tf_export import tf_export
+
+COMPRESSION_AUTO = "AUTO"
+COMPRESSION_NONE = None
+_PARALLEL_EPOCHS = "parallel_epochs"
+_DISTRIBUTED_EPOCH = "distributed_epoch"
+
+
+@tf_export("data.experimental.service.ShardingPolicy")
+class ShardingPolicy(enum.IntEnum):
+  """Specifies how to shard data among tf.data service workers.
+
+  OFF: No sharding will be performed. Each worker produces the entire dataset
+  without any sharding. With this mode, the best practice is to shuffle the
+  dataset nondeterministically so that workers process the dataset in different
+  orders. If workers are restarted or join the cluster mid-job, they will begin
+  processing the dataset from the beginning.
+
+  DYNAMIC: The input dataset is dynamically split among workers at runtime. Each
+  worker gets the next split when it reads data from the dispatcher. Data is
+  produced non-deterministically in this mode. Dynamic sharding works well with
+  varying-sized tf.data service clusters, e.g., when you need to auto-scale your
+  workers. Dynamic sharding provides at-most once visitation guarantees. No
+  examples will be repeated, but some may be missed if a tf.data service worker
+  gets restarted while processing a file.
+
+  The following are static sharding policies. The semantics are similar to
+  `tf.data.experimental.AutoShardPolicy`. These policies require:
+  * The tf.data service cluster is configured with a fixed list of workers
+    in DispatcherConfig.
+  * Each client only reads from the local tf.data service worker.
+
+  If a worker is restarted while performing static sharding, the worker will
+  begin processing its shard again from the beginning.
+
+  FILE: Shards by input files (i.e. each worker will get a fixed set of files to
+  process). When this option is selected, make sure that there is at least as
+  many files as workers. If there are fewer input files than workers, a runtime
+  error will be raised.
+
+  DATA: Shards by elements produced by the dataset. Each worker will process the
+  whole dataset and discard the portion that is not for itself. Note that for
+  this mode to correctly partition the dataset elements, the dataset needs to
+  produce elements in a deterministic order.
+
+  FILE_OR_DATA: Attempts FILE-based sharding, falling back to DATA-based
+  sharding on failure.
+
+  HINT: Looks for the presence of `shard(SHARD_HINT, ...)` which is treated as a
+  placeholder to replace with `shard(num_workers, worker_index)`.
+  """
+
+  # LINT.IfChange(tf_data_service_sharding_policy)
+  OFF = 0
+  DYNAMIC = 1
+  FILE = 2
+  DATA = 3
+  FILE_OR_DATA = 4
+  HINT = 5
+  # LINT.ThenChange()
+
+  def _to_proto(self) -> data_service_pb2.ProcessingModeDef.ShardingPolicy:
+    """Converts the policy to ProcessingModeDef proto enum."""
+
+    if self == ShardingPolicy.OFF:
+      return data_service_pb2.ProcessingModeDef.OFF
+    if self == ShardingPolicy.DYNAMIC:
+      return data_service_pb2.ProcessingModeDef.DYNAMIC
+    if self == ShardingPolicy.FILE:
+      return data_service_pb2.ProcessingModeDef.FILE
+    if self == ShardingPolicy.DATA:
+      return data_service_pb2.ProcessingModeDef.DATA
+    if self == ShardingPolicy.FILE_OR_DATA:
+      return data_service_pb2.ProcessingModeDef.FILE_OR_DATA
+    if self == ShardingPolicy.HINT:
+      return data_service_pb2.ProcessingModeDef.HINT
+    raise ValueError(f"Unable to convert sharding policy {self!r} to proto.")
+
+
+@tf_export("data.experimental.service.CrossTrainerCache")
+class CrossTrainerCache:
+  """Options related to the tf.data service cross trainer cache.
+
+  This is used to enable cross-trainer cache when distributing a dataset. For
+  example:
+
+  ```
+  dataset = dataset.apply(tf.data.experimental.service.distribute(
+      processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+      service=FLAGS.tf_data_service_address,
+      job_name="job",
+      cross_trainer_cache=data_service_ops.CrossTrainerCache(
+          trainer_id=trainer_id())))
+  ```
+
+  For more details, refer to
+  https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers.
+  """
+
+  def __init__(self, trainer_id):
+    """Constructs a CrossTrainerCache.
+
+    Args:
+      trainer_id: Each training job has a unique ID. Once a job has consumed
+      data, the data remains in the cache and is re-used by jobs with different
+      `trainer_id`s. Requests with the same `trainer_id` do not re-use data.
+
+    Raises:
+      ValueError if `trainer_id` is empty.
+    """
+    if not trainer_id:
+      raise ValueError(
+          "tf.data service cross-trainer cache requires a non-empty trainer ID."
+      )
+    self.trainer_id = trainer_id
+
+  def _to_proto(self) -> data_service_pb2.CrossTrainerCacheOptions:
+    return data_service_pb2.CrossTrainerCacheOptions(trainer_id=self.trainer_id)
+
+
+def _get_validated_sharding_policy(processing_mode) -> ShardingPolicy:
+  """Validates `processing_mode` and converts it to ShardingPolicy."""
+
+  if isinstance(processing_mode, ShardingPolicy):
+    return processing_mode
+  if processing_mode == _PARALLEL_EPOCHS:
+    return ShardingPolicy.OFF
+  if processing_mode == _DISTRIBUTED_EPOCH:
+    return ShardingPolicy.DYNAMIC
+
+  raise ValueError("tf.data service processing mode should be a "
+                   "`tf.data.experimental.service.ShardingPolicy`, "
+                   "`\"parallel_epochs\"`, or `\"distributed_epoch\"`. Got "
+                   f"{processing_mode!r}.")
+
+
+def _validate_job_name(job_name) -> None:
+  if job_name is None:
+    return
+  if not isinstance(job_name, str):
+    raise ValueError("`job_name` must be a string, but `job_name` was of type "
+                     f"{type(job_name)}. job_name={job_name}")
+  if not job_name:
+    raise ValueError("`job_name` must not be empty")
+
+
+def _validate_compression(compression) -> None:
+  valid_compressions = [COMPRESSION_AUTO, COMPRESSION_NONE]
+  if compression not in valid_compressions:
+    raise ValueError(f"Invalid `compression` argument: {compression}. "
+                     f"Must be one of {valid_compressions}.")
+
+
+def _get_compression_proto(
+    compression) -> data_service_pb2.DataServiceMetadata.Compression:
+  if compression == COMPRESSION_AUTO:
+    return data_service_pb2.DataServiceMetadata.COMPRESSION_SNAPPY
+  if compression == COMPRESSION_NONE:
+    return data_service_pb2.DataServiceMetadata.COMPRESSION_OFF
+  raise ValueError(f"Invalid `compression` argument: {compression}. "
+                   f"Must be one of {[COMPRESSION_AUTO, COMPRESSION_NONE]}.")
+
+
+def _to_tensor(dataset_id) -> tensor.Tensor:
+  """Converts `dataset_id` to Tensor."""
+
+  if isinstance(dataset_id, tensor.Tensor):
+    return dataset_id
+  if isinstance(dataset_id, str) or isinstance(dataset_id, bytes):
+    return ops.convert_to_tensor(
+        dataset_id, dtype=dtypes.string, name="dataset_id")
+  return ops.convert_to_tensor(
+      dataset_id, dtype=dtypes.int64, name="dataset_id")
+
+
+def _to_string(dataset_id) -> str:
+  """Converts `dataset_id` to string."""
+
+  if isinstance(dataset_id, tensor.Tensor):
+    return (dataset_id if dataset_id.dtype == dtypes.string else
+            string_ops.as_string(dataset_id))
+  return (dataset_id.decode()
+          if isinstance(dataset_id, bytes) else str(dataset_id))
+
+
+class _DataServiceDatasetV2(dataset_ops.DatasetSource):
+  """A `Dataset` that reads elements from the tf.data service."""
+
+  def __init__(self,
+               dataset_id,
+               processing_mode,
+               address,
+               element_spec,
+               protocol,
+               data_transfer_protocol,
+               job_name=None,
+               consumer_index=None,
+               num_consumers=None,
+               max_outstanding_requests=None,
+               task_refresh_interval_hint_ms=None,
+               cross_trainer_cache=None,
+               target_workers="AUTO"):
+    """Constructs a _DataServiceDatasetV2.
+
+    Args:
+      dataset_id: The dataset id for the dataset to read from.
+      processing_mode: A `tf.data.experimental.service.ShardingPolicy`
+        specifying how to shard the dataset among tf.data workers. See
+        `tf.data.experimental.service.ShardingPolicy` for details. For backwards
+        compatibility, `processing_mode` may also be set to the strings
+        `"parallel_epochs"` or `"distributed_epoch"`, which are respectively
+        equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+      address: The tf.data service address, e.g. "localhost:5000".
+      element_spec: The dataset element spec for the dataset to read from.
+      protocol: The protocol to use for communicating with the tf.data service,
+        e.g. "grpc".
+      data_transfer_protocol: (Optional.) The protocol to use for transferring
+        data with the tf.data service. By default, data is transferred using
+        gRPC.
+      job_name: (Optional.) The name of the job. If provided, it must be a
+        non-empty string or Tensor. This argument makes it possible for multiple
+        datasets to share the same job. The default behavior is that the dataset
+        creates anonymous, exclusively owned jobs.
+      consumer_index: (Optional.) The index of the consumer in the range from
+        `0` to `num_consumers`. Must be specified alongside `num_consumers`.
+        When specified, consumers will read from the job in a strict round-robin
+        order, instead of the default first-come-first-served order.
+      num_consumers: (Optional.) The number of consumers which will consume from
+        the job. Must be specified alongside `consumer_index`. When specified,
+        consumers will read from the job in a strict round-robin order, instead
+        of the default first-come-first-served order. When `num_consumers` is
+        specified, the dataset must have infinite cardinality to prevent a
+        producer from running out of data early and causing consumers to go out
+        of sync.
+      max_outstanding_requests: (Optional.) A limit on how many elements may be
+        requested at the same time. You can use this option to control the
+        amount of memory used, since `distribute` won't use more than
+        `element_size` * `max_outstanding_requests` of memory.
+      task_refresh_interval_hint_ms: (Optional.) A hint for how often to query
+        the dispatcher for task changes.
+      cross_trainer_cache: (Optional.) If a `CrossTrainerCache` object is
+        provided, dataset iteration will be shared across concurrently running
+        trainers. See
+        https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers
+        for details.
+      target_workers: (Optional.) Which workers to read from. If `"AUTO"`,
+        tf.data runtime decides which workers to read from. If `"ANY"`, reads
+        from any tf.data service workers. If `"LOCAL"`, only reads from local
+        in-processs tf.data service workers. `"AUTO"` works well for most cases,
+        while users can specify other targets. For example, `"LOCAL"` helps
+        avoid RPCs and data copy if every TF worker colocates with a tf.data
+        service worker. Consumers of a shared job must use the same
+        `target_workers`. Defaults to `"AUTO"`.
+    """
+    if consumer_index is None != num_consumers is None:
+      raise ValueError(
+          "Must either set both `consumer_index` and `num_consumers`, "
+          "or neither. ",
+          f"consumer_index={consumer_index}, num_consumers={num_consumers}")
+    if num_consumers is not None and job_name is None:
+      raise ValueError("`job_name` must be set when setting `num_consumers`. "
+                       f"num_consumers was set to {num_consumers}.")
+
+    processing_mode_def = data_service_pb2.ProcessingModeDef(
+        sharding_policy=_get_validated_sharding_policy(
+            processing_mode)._to_proto())
+    if job_name is None:
+      job_name = ""
+    if max_outstanding_requests is None:
+      max_outstanding_requests = dataset_ops.AUTOTUNE
+    if task_refresh_interval_hint_ms is None:
+      task_refresh_interval_hint_ms = dataset_ops.AUTOTUNE
+
+    self._dataset_id = _to_tensor(dataset_id)
+    self._processing_mode = ops.convert_to_tensor(
+        processing_mode_def.SerializeToString(),
+        dtype=dtypes.string,
+        name="processing_mode")
+    self._address = ops.convert_to_tensor(
+        address, dtype=dtypes.string, name="address")
+    self._protocol = ops.convert_to_tensor(
+        protocol, dtype=dtypes.string, name="protocol")
+    self._job_name = ops.convert_to_tensor(
+        job_name, dtype=dtypes.string, name="job_name")
+    self._consumer_index = ops.convert_to_tensor(
+        -1 if consumer_index is None else consumer_index,
+        dtype=dtypes.int64,
+        name="consumer_index")
+    self._num_consumers = ops.convert_to_tensor(
+        -1 if num_consumers is None else num_consumers,
+        dtype=dtypes.int64,
+        name="num_consumers")
+    self._max_outstanding_requests = ops.convert_to_tensor(
+        max_outstanding_requests,
+        dtype=dtypes.int64,
+        name="max_outstanding_requests")
+    self._element_spec = element_spec
+    uncompress_func = structured_function.StructuredFunctionWrapper(
+        lambda x: compression_ops.uncompress(x, output_spec=element_spec),
+        transformation_name="DataServiceDataset.uncompress()",
+        input_structure=tensor.TensorSpec(shape=(), dtype=dtypes.variant))
+    cross_trainer_cache_options = (
+        cross_trainer_cache._to_proto().SerializeToString()
+        if cross_trainer_cache else None)
+
+    compat_kwargs = {}
+    if data_transfer_protocol is not None:
+      compat_kwargs["data_transfer_protocol"] = data_transfer_protocol
+
+    # If `uncompress` is `True`, the dataset will query the servers to find
+    # out the actual compression used. It is always set to `True` the first
+    # time the graph is built, and set to false when serializing, so we will
+    # uncompress at most once.
+    uncompress = True
+    variant_tensor = gen_experimental_dataset_ops.data_service_dataset_v4(
+        dataset_id=self._dataset_id,
+        processing_mode=self._processing_mode,
+        address=self._address,
+        protocol=self._protocol,
+        job_name=self._job_name,
+        consumer_index=self._consumer_index,
+        num_consumers=self._num_consumers,
+        max_outstanding_requests=self._max_outstanding_requests,
+        task_refresh_interval_hint_ms=task_refresh_interval_hint_ms,
+        iteration_counter=(
+            gen_experimental_dataset_ops.dummy_iteration_counter()),
+        target_workers=target_workers,
+        uncompress=uncompress,
+        uncompress_fn=uncompress_func.function,
+        cross_trainer_cache_options=cross_trainer_cache_options,
+        **compat_kwargs,
+        **self._flat_structure)
+    super(_DataServiceDatasetV2, self).__init__(variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._element_spec
+
+
+class _DataServiceDatasetV1(dataset_ops.DatasetV1Adapter):
+  """A `Dataset` that executes its input through the tf.data service."""
+
+  @functools.wraps(_DataServiceDatasetV2.__init__)
+  def __init__(self, dataset_id, processing_mode, address, element_spec,
+               protocol, data_transfer_protocol, job_name, consumer_index,
+               num_consumers, max_outstanding_requests,
+               task_refresh_interval_hint_ms, cross_trainer_cache,
+               target_workers):
+
+    self._wrapped = _DataServiceDatasetV2(
+        dataset_id=dataset_id,
+        processing_mode=processing_mode,
+        address=address,
+        element_spec=element_spec,
+        protocol=protocol,
+        data_transfer_protocol=data_transfer_protocol,
+        job_name=job_name,
+        consumer_index=consumer_index,
+        num_consumers=num_consumers,
+        max_outstanding_requests=max_outstanding_requests,
+        task_refresh_interval_hint_ms=task_refresh_interval_hint_ms,
+        cross_trainer_cache=cross_trainer_cache,
+        target_workers=target_workers)
+    super(_DataServiceDatasetV1, self).__init__(self._wrapped)
+
+
+if tf2.enabled():
+  _DataServiceDataset = _DataServiceDatasetV2
+else:
+  _DataServiceDataset = _DataServiceDatasetV1
+
+
+def _parse_service(service) -> tuple[str, str]:
+  """Converts a tf.data service string into a (protocol, address) tuple.
+
+  Args:
+    service: A string in the format "protocol://address" or just "address". If
+      the string is only an address, the default protocol will be used.
+
+  Returns:
+    The (protocol, address) tuple
+  """
+  if not isinstance(service, str):
+    raise ValueError("`service` must be a string, but `service` was of type "
+                     f"{type(service)}. service={service}")
+  if not service:
+    raise ValueError("`service` must not be empty")
+  parts = service.split("://")
+  if len(parts) == 2:
+    protocol, address = parts
+  elif len(parts) == 1:
+    address = parts[0]
+    protocol = _pywrap_utils.TF_DATA_DefaultProtocol()
+  else:
+    raise ValueError("Malformed `service` string has multiple '://': "
+                     f"{service}.")
+  # TODO(aaudibert): Considering validating reachability of address here.
+  return (protocol, address)
+
+
+def _distribute(
+    processing_mode,
+    service,
+    job_name=None,
+    consumer_index=None,
+    num_consumers=None,
+    max_outstanding_requests=None,
+    task_refresh_interval_hint_ms=None,
+    data_transfer_protocol=None,
+    compression="AUTO",
+    cross_trainer_cache=None,
+    target_workers="AUTO",
+) -> Callable[dataset_ops.Dataset, dataset_ops.Dataset]:
+  """A transformation that moves dataset processing to the tf.data service.
+
+  This transformation is similar to `distribute`, but supports additional
+  parameters which we do not yet want to add to the public Python API.
+
+  Args:
+    processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying
+      how to shard the dataset among tf.data workers. See
+      `tf.data.experimental.service.ShardingPolicy` for details. For backwards
+      compatibility, `processing_mode` may also be set to the strings
+      `"parallel_epochs"` or `"distributed_epoch"`, which are respectively
+      equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    job_name: (Optional.) The name of the job. If provided, it must be a
+      non-empty string. This argument makes it possible for multiple datasets to
+      share the same job. The default behavior is that the dataset creates
+      anonymous, exclusively owned jobs.
+    consumer_index: (Optional.) The index of the consumer in the range from `0`
+      to `num_consumers`. Must be specified alongside `num_consumers`. When
+      specified, consumers will read from the job in a strict round-robin order,
+      instead of the default first-come-first-served order.
+    num_consumers: (Optional.) The number of consumers which will consume from
+      the job. Must be specified alongside `consumer_index`. When specified,
+      consumers will read from the job in a strict round-robin order, instead of
+      the default first-come-first-served order. When `num_consumers` is
+      specified, the dataset must have infinite cardinality to prevent a
+      producer from running out of data early and causing consumers to go out of
+      sync.
+    max_outstanding_requests: (Optional.) A limit on how many elements may be
+      requested at the same time. You can use this option to control the amount
+      of memory used, since `distribute` won't use more than `element_size` *
+      `max_outstanding_requests` of memory.
+    task_refresh_interval_hint_ms: (Optional.) A hint for how often to query the
+      dispatcher for task changes.
+    data_transfer_protocol: (Optional.) The protocol to use for transferring
+      data with the tf.data service. By default, data is transferred using gRPC.
+    compression: How to compress the dataset's elements before transferring them
+      over the network. "AUTO" leaves the decision of how to compress up to the
+      tf.data service runtime. `None` indicates not to compress.
+    cross_trainer_cache: (Optional.) If a `CrossTrainerCache` object is
+      provided, dataset iteration will be shared across concurrently running
+      trainers. See
+      https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers
+      for details.
+    target_workers: (Optional.) Which workers to read from. If `"AUTO"`, tf.data
+      runtime decides which workers to read from. If `"ANY"`, reads from any
+      tf.data service workers. If `"LOCAL"`, only reads from local in-processs
+      tf.data service workers. `"AUTO"` works well for most cases, while users
+      can specify other targets. For example, `"LOCAL"` helps avoid RPCs and
+      data copy if every TF worker colocates with a tf.data service worker.
+      Consumers of a shared job must use the same `target_workers`. Defaults to
+      `"AUTO"`.
+
+  Returns:
+    Dataset: A `Dataset` of the elements produced by the data service.
+  """
+  processing_mode = _get_validated_sharding_policy(processing_mode)
+  _validate_compression(compression)
+
+  def _apply_fn(dataset) -> dataset_ops.Dataset:  # pylint: disable=missing-docstring
+    dataset_id = _register_dataset(service, dataset, compression=compression)
+    return _from_dataset_id(
+        processing_mode,
+        service,
+        dataset_id,
+        dataset.element_spec,
+        job_name=job_name,
+        consumer_index=consumer_index,
+        num_consumers=num_consumers,
+        max_outstanding_requests=max_outstanding_requests,
+        task_refresh_interval_hint_ms=task_refresh_interval_hint_ms,
+        data_transfer_protocol=data_transfer_protocol,
+        cross_trainer_cache=cross_trainer_cache,
+        target_workers=target_workers)
+
+  return _apply_fn
+
+
+@tf_export("data.experimental.service.distribute")
+def distribute(
+    processing_mode,
+    service,
+    job_name=None,
+    consumer_index=None,
+    num_consumers=None,
+    max_outstanding_requests=None,
+    data_transfer_protocol=None,
+    compression="AUTO",
+    cross_trainer_cache=None,
+    target_workers="AUTO",
+) -> Callable[dataset_ops.Dataset, dataset_ops.Dataset]:
+  """A transformation that moves dataset processing to the tf.data service.
+
+  When you iterate over a dataset containing the `distribute` transformation,
+  the tf.data service creates a "job" which produces data for the dataset
+  iteration.
+
+  The tf.data service uses a cluster of workers to prepare data for training
+  your model.
+  The `processing_mode` argument to `tf.data.experimental.service.distribute`
+  describes how to leverage multiple workers to process the input dataset.
+  Currently, there are two processing modes to choose from: "distributed_epoch"
+  and "parallel_epochs".
+
+  "distributed_epoch" means that the dataset will be split across all tf.data
+  service workers.
+  The dispatcher produces "splits" for the dataset and sends them to workers for
+  further processing. For example, if a dataset begins with a list of filenames,
+  the dispatcher will iterate through the filenames and send the filenames to
+  tf.data workers, which will perform the rest of the dataset transformations on
+  those files. "distributed_epoch" is useful when your model needs to see each
+  element of the dataset exactly once, or if it needs to see the data in a
+  generally-sequential order. "distributed_epoch" only works for datasets with
+  splittable sources, such as `Dataset.from_tensor_slices`,
+  `Dataset.list_files`, or `Dataset.range`.
+
+  "parallel_epochs" means that the entire input dataset will be processed
+  independently by each of the tf.data service workers.
+  For this reason, it is important to shuffle data (e.g. filenames)
+  non-deterministically, so that each worker will process the elements of the
+  dataset in a different order. "parallel_epochs" can be used to distribute
+  datasets that aren't splittable.
+
+  With two workers, "parallel_epochs" will produce every element of the dataset
+  twice:
+
+  >>> dispatcher = tf.data.experimental.service.DispatchServer()
+  >>> dispatcher_address = dispatcher.target.split("://")[1]
+  >>> # Start two workers
+  >>> workers = [
+  ...     tf.data.experimental.service.WorkerServer(
+  ...         tf.data.experimental.service.WorkerConfig(
+  ...             dispatcher_address=dispatcher_address)) for _ in range(2)
+  ... ]
+  >>> dataset = tf.data.Dataset.range(10)
+  >>> dataset = dataset.apply(tf.data.experimental.service.distribute(
+  ...     processing_mode="parallel_epochs", service=dispatcher.target))
+  >>> print(sorted(list(dataset.as_numpy_iterator())))
+  [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
+
+  "distributed_epoch", on the other hand, will still produce each element once:
+
+  >>> dispatcher = tf.data.experimental.service.DispatchServer()
+  >>> dispatcher_address = dispatcher.target.split("://")[1]
+  >>> workers = [
+  ...     tf.data.experimental.service.WorkerServer(
+  ...         tf.data.experimental.service.WorkerConfig(
+  ...             dispatcher_address=dispatcher_address)) for _ in range(2)
+  ... ]
+  >>> dataset = tf.data.Dataset.range(10)
+  >>> dataset = dataset.apply(tf.data.experimental.service.distribute(
+  ...     processing_mode="distributed_epoch", service=dispatcher.target))
+  >>> print(sorted(list(dataset.as_numpy_iterator())))
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+  When using `apply(tf.data.experimental.service.distribute(...))`, the dataset
+  before the `apply` transformation executes within the tf.data service, while
+  the operations after `apply` happen within the local process.
+
+  >>> dispatcher = tf.data.experimental.service.DispatchServer()
+  >>> dispatcher_address = dispatcher.target.split("://")[1]
+  >>> workers = [
+  ...     tf.data.experimental.service.WorkerServer(
+  ...         tf.data.experimental.service.WorkerConfig(
+  ...             dispatcher_address=dispatcher_address)) for _ in range(2)
+  ... ]
+  >>> dataset = tf.data.Dataset.range(5)
+  >>> dataset = dataset.map(lambda x: x*x)
+  >>> dataset = dataset.apply(
+  ...    tf.data.experimental.service.distribute("parallel_epochs",
+  ...                                            dispatcher.target))
+  >>> dataset = dataset.map(lambda x: x+1)
+  >>> print(sorted(list(dataset.as_numpy_iterator())))
+  [1, 1, 2, 2, 5, 5, 10, 10, 17, 17]
+
+  In the above example, the dataset operations (before applying the `distribute`
+  function on the elements) will be executed on the tf.data workers,
+  and the elements are provided over RPC. The remaining transformations
+  (after the call to `distribute`) will be executed locally. The dispatcher
+  and the workers will bind to usused free ports (which are chosen at random),
+  in order to communicate with each other. However, to bind them to specific
+  ports, the `port` parameter can be passed.
+
+  The `job_name` argument allows jobs to be shared across multiple
+  datasets. Instead of each dataset creating its own job, all
+  datasets with the same `job_name` will consume from the same job. A new job
+  will be created for each iteration of the dataset (with each repetition of
+  `Dataset.repeat` counting as a new iteration). Suppose the `DispatchServer`
+  is serving on `localhost:5000` and two training workers (in either a single
+  client or multi-client setup) iterate over the below dataset, and there is a
+  single tf.data worker:
+
+  ```
+  range5_dataset = tf.data.Dataset.range(5)
+  dataset = range5_dataset.apply(tf.data.experimental.service.distribute(
+      "parallel_epochs", "localhost:5000", job_name="my_job_name"))
+  for iteration in range(3):
+    print(list(dataset))
+  ```
+
+  The elements of each job will be split between the two processes, with
+  elements being consumed by the processes on a first-come first-served basis.
+  One possible result is that process 1 prints
+
+  ```
+  [0, 2, 4]
+  [0, 1, 3]
+  [1]
+  ```
+
+  and process 2 prints
+
+  ```
+  [1, 3]
+  [2, 4]
+  [0, 2, 3, 4]
+  ```
+
+  Job names must not be re-used across different training jobs within the
+  lifetime of the tf.data service. In general, the tf.data service is expected
+  to live for the duration of a single training job.
+  To use the tf.data service with multiple training jobs, make sure to use
+  different job names to avoid conflicts. For example, suppose a training job
+  calls `distribute` with `job_name="job"` and reads until end of input. If
+  another independent job connects to the same tf.data service and tries to read
+  from `job_name="job"`, it will immediately receive end of input, without
+  getting any data.
+
+  **Coordinated data read**
+
+  By default, when multiple consumers read from the same job, they receive data
+  on a first-come first-served basis. In some use cases, it is advantageous to
+  coordinate the consumers. At each step, consumers read data from the same
+  worker.
+
+  For example, the tf.data service can be used to coordinate example sizes
+  across a cluster during synchronous training, so that during each step all
+  replicas train on similar-sized elements. To achieve this, define a dataset
+  which generates rounds of `num_consumers` consecutive similar-sized batches,
+  then enable coordinated reads by setting `consumer_index` and `num_consumers`.
+
+  NOTE: To keep consumers in sync, round robin data consumption requires that
+  the dataset have infinite cardinality. You can get this by adding `.repeat()`
+  at the end of the dataset definition.
+
+  **Keras and Distribution Strategies**
+
+  The dataset produced by the `distribute` transformation can be passed to
+  Keras' `Model.fit` or Distribution Strategy's
+  `tf.distribute.Strategy.experimental_distribute_dataset` like any other
+  `tf.data.Dataset`. We recommend setting a `job_name` on the call to
+  `distribute` so that if there are multiple workers, they read data from the
+  same job. Note that the autosharding normally performed by
+  `experimental_distribute_dataset` will be disabled when setting a `job_name`,
+  since sharing the job already results in splitting data across the workers.
+  When using a shared job, data will be dynamically balanced across workers, so
+  that they reach end of input about the same time. This results in better
+  worker utilization than with autosharding, where each worker processes an
+  independent set of files, and some workers may run out of data earlier than
+  others.
+
+  Args:
+    processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying
+      how to shard the dataset among tf.data workers. See
+      `tf.data.experimental.service.ShardingPolicy` for details. For backwards
+      compatibility, `processing_mode` may also be set to the strings
+      `"parallel_epochs"` or `"distributed_epoch"`, which are respectively
+      equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    job_name: (Optional.) The name of the job. If provided, it must be a
+      non-empty string. This argument makes it possible for multiple datasets to
+      share the same job. The default behavior is that the dataset creates
+      anonymous, exclusively owned jobs.
+    consumer_index: (Optional.) The index of the consumer in the range from `0`
+      to `num_consumers`. Must be specified alongside `num_consumers`. When
+      specified, consumers will read from the job in a strict round-robin order,
+      instead of the default first-come-first-served order.
+    num_consumers: (Optional.) The number of consumers which will consume from
+      the job. Must be specified alongside `consumer_index`. When specified,
+      consumers will read from the job in a strict round-robin order, instead of
+      the default first-come-first-served order. When `num_consumers` is
+      specified, the dataset must have infinite cardinality to prevent a
+      producer from running out of data early and causing consumers to go out of
+      sync.
+    max_outstanding_requests: (Optional.) A limit on how many elements may be
+      requested at the same time. You can use this option to control the amount
+      of memory used, since `distribute` won't use more than `element_size` *
+      `max_outstanding_requests` of memory.
+    data_transfer_protocol: (Optional.) The protocol to use for transferring
+      data with the tf.data service. By default, data is transferred using gRPC.
+    compression: How to compress the dataset's elements before transferring them
+      over the network. "AUTO" leaves the decision of how to compress up to the
+      tf.data service runtime. `None` indicates not to compress.
+    cross_trainer_cache: (Optional.) If a `CrossTrainerCache` object is
+      provided, dataset iteration will be shared across concurrently running
+      trainers. See
+      https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers
+      for details.
+    target_workers: (Optional.) Which workers to read from. If `"AUTO"`, tf.data
+      runtime decides which workers to read from. If `"ANY"`, reads from any
+      tf.data service workers. If `"LOCAL"`, only reads from local in-processs
+      tf.data service workers. `"AUTO"` works well for most cases, while users
+      can specify other targets. For example, `"LOCAL"` helps avoid RPCs and
+      data copy if every TF worker colocates with a tf.data service worker.
+      Consumers of a shared job must use the same `target_workers`. Defaults to
+      `"AUTO"`.
+
+  Returns:
+    Dataset: A `Dataset` of the elements produced by the data service.
+  """
+  _validate_job_name(job_name)
+  return _distribute(
+      processing_mode=processing_mode,
+      service=service,
+      job_name=job_name,
+      consumer_index=consumer_index,
+      num_consumers=num_consumers,
+      max_outstanding_requests=max_outstanding_requests,
+      data_transfer_protocol=data_transfer_protocol,
+      compression=compression,
+      cross_trainer_cache=cross_trainer_cache,
+      target_workers=target_workers)
+
+
+def _register_dataset(
+    service, dataset, compression, dataset_id=None) -> tensor.Tensor:
+  """Registers a dataset with the tf.data service.
+
+  This transformation is similar to `register_dataset`, but supports additional
+  parameters which we do not yet want to add to the public Python API.
+
+  Args:
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    dataset: A `tf.data.Dataset` to register with the tf.data service.
+    compression: How to compress the dataset's elements before transferring them
+      over the network. "AUTO" leaves the decision of how to compress up to the
+      tf.data service runtime. `None` indicates not to compress.
+    dataset_id: (Optional.) By default, tf.data service generates a unique
+      (string) ID for each registered dataset. If a `dataset_id` is provided, it
+      will use the specified ID. If a dataset with a matching ID already exists,
+      no new dataset is registered. This is useful if multiple training jobs
+      want to (re)use the same dataset for training. In this case, they can
+      register the dataset with the same dataset ID.
+
+  Returns:
+    A scalar string tensor representing the dataset ID.
+  """
+  _validate_compression(compression)
+
+  if isinstance(service, tuple):
+    protocol, address = service
+  else:
+    protocol, address = _parse_service(service)
+  external_state_policy = dataset.options().experimental_external_state_policy
+  if external_state_policy is None:
+    external_state_policy = ExternalStatePolicy.WARN
+
+  encoded_spec = None
+  if context.executing_eagerly():
+    encoded_spec = nested_structure_coder.encode_structure(
+        dataset.element_spec).SerializeToString()
+
+  if compression == COMPRESSION_AUTO:
+    dataset = dataset.map(
+        lambda *x: compression_ops.compress(x),
+        num_parallel_calls=dataset_ops.AUTOTUNE)
+  dataset = dataset._apply_debug_options()  # pylint: disable=protected-access
+
+  metadata = data_service_pb2.DataServiceMetadata(
+      element_spec=encoded_spec,
+      compression=_get_compression_proto(compression))
+
+  return gen_experimental_dataset_ops.register_dataset_v2(
+      dataset._variant_tensor,  # pylint: disable=protected-access
+      address=address,
+      protocol=protocol,
+      external_state_policy=external_state_policy.value,
+      requested_dataset_id=dataset_id,
+      metadata=metadata.SerializeToString())
+
+
+@tf_export("data.experimental.service.register_dataset")
+def register_dataset(
+    service, dataset, compression="AUTO", dataset_id=None) -> tensor.Tensor:
+  """Registers a dataset with the tf.data service.
+
+  `register_dataset` registers a dataset with the tf.data service so that
+  datasets can be created later with
+  `tf.data.experimental.service.from_dataset_id`. This is useful when the
+  dataset
+  is registered by one process, then used in another process. When the same
+  process is both registering and reading from the dataset, it is simpler to use
+  `tf.data.experimental.service.distribute` instead.
+
+  If the dataset is already registered with the tf.data service,
+  `register_dataset` returns the already-registered dataset's id.
+
+  >>> dispatcher = tf.data.experimental.service.DispatchServer()
+  >>> dispatcher_address = dispatcher.target.split("://")[1]
+  >>> worker = tf.data.experimental.service.WorkerServer(
+  ...     tf.data.experimental.service.WorkerConfig(
+  ...         dispatcher_address=dispatcher_address))
+  >>> dataset = tf.data.Dataset.range(10)
+  >>> dataset_id = tf.data.experimental.service.register_dataset(
+  ...     dispatcher.target, dataset)
+  >>> dataset = tf.data.experimental.service.from_dataset_id(
+  ...     processing_mode="parallel_epochs",
+  ...     service=dispatcher.target,
+  ...     dataset_id=dataset_id,
+  ...     element_spec=dataset.element_spec)
+  >>> print(list(dataset.as_numpy_iterator()))
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+  Args:
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    dataset: A `tf.data.Dataset` to register with the tf.data service.
+    compression: (Optional.) How to compress the dataset's elements before
+      transferring them over the network. "AUTO" leaves the decision of how to
+      compress up to the tf.data service runtime. `None` indicates not to
+      compress.
+    dataset_id: (Optional.) By default, tf.data service generates a unique
+      (string) ID for each registered dataset. If a `dataset_id` is provided, it
+      will use the specified ID. If a dataset with a matching ID already exists,
+      no new dataset is registered. This is useful if multiple training jobs
+      want to (re)use the same dataset for training. In this case, they can
+      register the dataset with the same dataset ID.
+
+  Returns:
+    A scalar string tensor representing the dataset ID.
+  """
+  return _register_dataset(service, dataset, compression, dataset_id)
+
+
+def _from_dataset_id(processing_mode,
+                     service,
+                     dataset_id,
+                     element_spec,
+                     job_name=None,
+                     consumer_index=None,
+                     num_consumers=None,
+                     max_outstanding_requests=None,
+                     task_refresh_interval_hint_ms=None,
+                     data_transfer_protocol=None,
+                     cross_trainer_cache=None,
+                     target_workers="AUTO") -> dataset_ops.Dataset:
+  """Creates a dataset which reads data from the tf.data service.
+
+  This transformation is similar to `from_dataset_id`, but supports additional
+  parameters which we do not yet want to add to the public Python API.
+
+  Args:
+    processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying
+      how to shard the dataset among tf.data workers. See
+      `tf.data.experimental.service.ShardingPolicy` for details. For backwards
+      compatibility, `processing_mode` may also be set to the strings
+      `"parallel_epochs"` or `"distributed_epoch"`, which are respectively
+      equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    dataset_id: The id of the dataset to read from. This id is returned by
+      `register_dataset` when the dataset is registered with the tf.data
+      service.
+    element_spec: A nested structure of `tf.TypeSpec`s representing the type of
+      elements produced by the dataset. This argument is only required inside a
+      tf.function. Use `tf.data.Dataset.element_spec` to get the element spec
+      for a given dataset.
+    job_name: (Optional.) The name of the job. If provided, it must be a
+      non-empty string or tensor. This argument makes it possible for multiple
+      datasets to share the same job. The default behavior is that the dataset
+      creates anonymous, exclusively owned jobs.
+    consumer_index: (Optional.) The index of the consumer in the range from `0`
+      to `num_consumers`. Must be specified alongside `num_consumers`. When
+      specified, consumers will read from the job in a strict round-robin order,
+      instead of the default first-come-first-served order.
+    num_consumers: (Optional.) The number of consumers which will consume from
+      the job. Must be specified alongside `consumer_index`. When specified,
+      consumers will read from the job in a strict round-robin order, instead of
+      the default first-come-first-served order. When `num_consumers` is
+      specified, the dataset must have infinite cardinality to prevent a
+      producer from running out of data early and causing consumers to go out of
+      sync.
+    max_outstanding_requests: (Optional.) A limit on how many elements may be
+      requested at the same time. You can use this option to control the amount
+      of memory used, since `distribute` won't use more than `element_size` *
+      `max_outstanding_requests` of memory.
+    task_refresh_interval_hint_ms: (Optional.) A hint for how often to query the
+      dispatcher for task changes.
+    data_transfer_protocol: (Optional.) The protocol to use for transferring
+      data with the tf.data service. By default, data is transferred using gRPC.
+    cross_trainer_cache: (Optional.) If a `CrossTrainerCache` object is
+      provided, dataset iteration will be shared across concurrently running
+      trainers. See
+      https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers
+      for details.
+    target_workers: (Optional.) Which workers to read from. If `"AUTO"`, tf.data
+      runtime decides which workers to read from. If `"ANY"`, reads from any
+      tf.data service workers. If `"LOCAL"`, only reads from local in-processs
+      tf.data service workers. `"AUTO"` works well for most cases, while users
+      can specify other targets. For example, `"LOCAL"` helps avoid RPCs and
+      data copy if every TF worker colocates with a tf.data service worker.
+      Consumers of a shared job must use the same `target_workers`. Defaults to
+      `"AUTO"`.
+
+  Returns:
+    A `tf.data.Dataset` which reads from the tf.data service.
+  """
+  def _get_element_spec():
+    """Fetches the element spec from the server."""
+    data_service_metadata = None
+    dataset_id_val = tensor_util.constant_value(dataset_id)
+    try:
+      data_service_metadata = (
+          _pywrap_server_lib.TF_DATA_GetDataServiceMetadataByID(
+              dataset_id_val, address, protocol
+          )
+      )
+    except NotImplementedError as err:
+      raise ValueError(
+          "The tf.data service is running an earlier version of TensorFlow "
+          "that requires specifying `element_spec` as an argument to "
+          "`from_dataset_id`. Please either supply an element spec or update "
+          "the tf.data service to the latest version.") from err
+    except RuntimeError:
+      # This error results from dataset ID not found. A more appropriate error
+      # will be raised when the dataset is created.
+      pass
+
+    if not data_service_metadata or not data_service_metadata.element_spec:
+      dataset_id_val = tensor_util.constant_value(dataset_id)
+      raise ValueError(
+          f"Failed to fetch element spec for dataset id {dataset_id_val} from "
+          "tf.data service. If the dataset was registered in graph mode or "
+          "inside a tf.function, the `element_spec` must be specified as an "
+          "argument to `from_dataset_id`.")
+
+    struct_pb = nested_structure_coder.struct_pb2.StructuredValue()
+    struct_pb.ParseFromString(data_service_metadata.element_spec)
+    return nested_structure_coder.decode_proto(struct_pb)
+
+  processing_mode = _get_validated_sharding_policy(processing_mode)
+  if isinstance(service, tuple):
+    protocol, address = service
+  else:
+    protocol, address = _parse_service(service)
+  if job_name is not None:
+    if not isinstance(job_name, str) and not isinstance(
+        job_name, tensor.Tensor):
+      raise ValueError(
+          "`job_name` must be a string or Tensor, but `job_name` was of type "
+          f"{type(job_name)}. job_name={job_name}.")
+
+  if not element_spec:
+    if not context.executing_eagerly():
+      raise ValueError(
+          "In graph mode `element_spec` must be provided manually.")
+    element_spec = _get_element_spec()
+
+  dataset = _DataServiceDataset(
+      dataset_id=dataset_id,
+      processing_mode=processing_mode,
+      address=address,
+      element_spec=element_spec,
+      protocol=protocol,
+      data_transfer_protocol=data_transfer_protocol,
+      job_name=job_name,
+      consumer_index=consumer_index,
+      num_consumers=num_consumers,
+      max_outstanding_requests=max_outstanding_requests,
+      task_refresh_interval_hint_ms=task_refresh_interval_hint_ms,
+      cross_trainer_cache=cross_trainer_cache,
+      target_workers=target_workers)
+
+  # Disable autosharding for shared jobs.
+  if job_name is not None:
+    options = options_lib.Options()
+    options.experimental_distribute.auto_shard_policy = AutoShardPolicy.OFF
+    dataset = dataset.with_options(options)
+  return dataset
+
+
+@tf_export("data.experimental.service.from_dataset_id")
+def from_dataset_id(processing_mode,
+                    service,
+                    dataset_id,
+                    element_spec=None,
+                    job_name=None,
+                    consumer_index=None,
+                    num_consumers=None,
+                    max_outstanding_requests=None,
+                    data_transfer_protocol=None,
+                    cross_trainer_cache=None,
+                    target_workers="AUTO") -> dataset_ops.Dataset:
+  """Creates a dataset which reads data from the tf.data service.
+
+  This is useful when the dataset is registered by one process, then used in
+  another process. When the same process is both registering and reading from
+  the dataset, it is simpler to use `tf.data.experimental.service.distribute`
+  instead.
+
+  Before using `from_dataset_id`, the dataset must have been registered with the
+  tf.data service using `tf.data.experimental.service.register_dataset`.
+  `register_dataset` returns a dataset id for the registered dataset. That is
+  the `dataset_id` which should be passed to `from_dataset_id`.
+
+  The `element_spec` argument indicates the `tf.TypeSpec`s for the elements
+  produced by the dataset. Currently `element_spec` must be explicitly
+  specified, and match the dataset registered under `dataset_id`. `element_spec`
+  defaults to `None` so that in the future we can support automatically
+  discovering the `element_spec` by querying the tf.data service.
+
+  `tf.data.experimental.service.distribute` is a convenience method which
+  combines `register_dataset` and `from_dataset_id` into a dataset
+  transformation.
+  See the documentation for `tf.data.experimental.service.distribute` for more
+  detail about how `from_dataset_id` works.
+
+  >>> dispatcher = tf.data.experimental.service.DispatchServer()
+  >>> dispatcher_address = dispatcher.target.split("://")[1]
+  >>> worker = tf.data.experimental.service.WorkerServer(
+  ...     tf.data.experimental.service.WorkerConfig(
+  ...         dispatcher_address=dispatcher_address))
+  >>> dataset = tf.data.Dataset.range(10)
+  >>> dataset_id = tf.data.experimental.service.register_dataset(
+  ...     dispatcher.target, dataset)
+  >>> dataset = tf.data.experimental.service.from_dataset_id(
+  ...     processing_mode="parallel_epochs",
+  ...     service=dispatcher.target,
+  ...     dataset_id=dataset_id,
+  ...     element_spec=dataset.element_spec)
+  >>> print(list(dataset.as_numpy_iterator()))
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+  Args:
+    processing_mode: A `tf.data.experimental.service.ShardingPolicy` specifying
+      how to shard the dataset among tf.data workers. See
+      `tf.data.experimental.service.ShardingPolicy` for details. For backwards
+      compatibility, `processing_mode` may also be set to the strings
+      `"parallel_epochs"` or `"distributed_epoch"`, which are respectively
+      equivalent to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+    service: A string or a tuple indicating how to connect to the tf.data
+      service. If it's a string, it should be in the format
+      `[<protocol>://]<address>`, where `<address>` identifies the dispatcher
+        address and `<protocol>` can optionally be used to override the default
+        protocol to use. If it's a tuple, it should be (protocol, address).
+    dataset_id: The id of the dataset to read from. This id is returned by
+      `register_dataset` when the dataset is registered with the tf.data
+      service.
+    element_spec: A nested structure of `tf.TypeSpec`s representing the type of
+      elements produced by the dataset. This argument is only required inside a
+      tf.function. Use `tf.data.Dataset.element_spec` to get the element spec
+      for a given dataset.
+    job_name: (Optional.) The name of the job. If provided, it must be a
+      non-empty string. This argument makes it possible for multiple datasets to
+      share the same job. The default behavior is that the dataset creates
+      anonymous, exclusively owned jobs.
+    consumer_index: (Optional.) The index of the consumer in the range from `0`
+      to `num_consumers`. Must be specified alongside `num_consumers`. When
+      specified, consumers will read from the job in a strict round-robin order,
+      instead of the default first-come-first-served order.
+    num_consumers: (Optional.) The number of consumers which will consume from
+      the job. Must be specified alongside `consumer_index`. When specified,
+      consumers will read from the job in a strict round-robin order, instead of
+      the default first-come-first-served order. When `num_consumers` is
+      specified, the dataset must have infinite cardinality to prevent a
+      producer from running out of data early and causing consumers to go out of
+      sync.
+    max_outstanding_requests: (Optional.) A limit on how many elements may be
+      requested at the same time. You can use this option to control the amount
+      of memory used, since `distribute` won't use more than `element_size` *
+      `max_outstanding_requests` of memory.
+    data_transfer_protocol: (Optional.) The protocol to use for transferring
+      data with the tf.data service. By default, data is transferred using gRPC.
+    cross_trainer_cache: (Optional.) If a `CrossTrainerCache` object is
+      provided, dataset iteration will be shared across concurrently running
+      trainers. See
+      https://www.tensorflow.org/api_docs/python/tf/data/experimental/service#sharing_tfdata_service_with_concurrent_trainers
+      for details.
+    target_workers: (Optional.) Which workers to read from. If `"AUTO"`, tf.data
+      runtime decides which workers to read from. If `"ANY"`, reads from any
+      tf.data service workers. If `"LOCAL"`, only reads from local in-processs
+      tf.data service workers. `"AUTO"` works well for most cases, while users
+      can specify other targets. For example, `"LOCAL"` helps avoid RPCs and
+      data copy if every TF worker colocates with a tf.data service worker.
+      Consumers of a shared job must use the same `target_workers`. Defaults to
+      `"AUTO"`.
+
+  Returns:
+    A `tf.data.Dataset` which reads from the tf.data service.
+  """
+  _validate_job_name(job_name)
+  if job_name is not None:
+    job_name = string_ops.string_join(
+        ["dataset_id=", _to_string(dataset_id), job_name], "/")
+
+  return _from_dataset_id(
+      processing_mode=processing_mode,
+      service=service,
+      dataset_id=dataset_id,
+      element_spec=element_spec,
+      job_name=job_name,
+      consumer_index=consumer_index,
+      num_consumers=num_consumers,
+      max_outstanding_requests=max_outstanding_requests,
+      data_transfer_protocol=data_transfer_protocol,
+      cross_trainer_cache=cross_trainer_cache,
+      target_workers=target_workers)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/error_ops.py

@@ -0,0 +1,51 @@
+# 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.
+# ==============================================================================
+"""Ignore_errors dataset transformations."""
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.ignore_errors")
+@deprecation.deprecated(None, "Use `tf.data.Dataset.ignore_errors` instead.")
+def ignore_errors(log_warning=False):
+  """Creates a `Dataset` from another `Dataset` and silently ignores any errors.
+
+  Use this transformation to produce a dataset that contains the same elements
+  as the input, but silently drops any elements that caused an error. For
+  example:
+
+  ```python
+  dataset = tf.data.Dataset.from_tensor_slices([1., 2., 0., 4.])
+
+  # Computing `tf.debugging.check_numerics(1. / 0.)` will raise an
+  InvalidArgumentError.
+  dataset = dataset.map(lambda x: tf.debugging.check_numerics(1. / x, "error"))
+
+  # Using `ignore_errors()` will drop the element that causes an error.
+  dataset =
+      dataset.apply(tf.data.experimental.ignore_errors())  # ==> {1., 0.5, 0.2}
+  ```
+  Args:
+     log_warning: (Optional.) A 'tf.bool' scalar indicating whether ignored
+      errors should be logged to stderr. Defaults to 'False'.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+  def _apply_fn(dataset):
+    return dataset.ignore_errors(log_warning)
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/get_single_element.py

@@ -0,0 +1,109 @@
+# 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.
+# ==============================================================================
+"""Python wrappers for Datasets and Iterators."""
+from tensorflow.python.types import data as data_types
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.get_single_element()`.")
+@tf_export("data.experimental.get_single_element")
+def get_single_element(dataset):
+  """Returns the single element of the `dataset` as a nested structure of tensors.
+
+  The function enables you to use a `tf.data.Dataset` in a stateless
+  "tensor-in tensor-out" expression, without creating an iterator.
+  This facilitates the ease of data transformation on tensors using the
+  optimized `tf.data.Dataset` abstraction on top of them.
+
+  For example, lets consider a `preprocessing_fn` which would take as an
+  input the raw features and returns the processed feature along with
+  it's label.
+
+  ```python
+  def preprocessing_fn(raw_feature):
+    # ... the raw_feature is preprocessed as per the use-case
+    return feature
+
+  raw_features = ...  # input batch of BATCH_SIZE elements.
+  dataset = (tf.data.Dataset.from_tensor_slices(raw_features)
+             .map(preprocessing_fn, num_parallel_calls=BATCH_SIZE)
+             .batch(BATCH_SIZE))
+
+  processed_features = tf.data.experimental.get_single_element(dataset)
+  ```
+
+  In the above example, the `raw_features` tensor of length=BATCH_SIZE
+  was converted to a `tf.data.Dataset`. Next, each of the `raw_feature` was
+  mapped using the `preprocessing_fn` and the processed features were
+  grouped into a single batch. The final `dataset` contains only one element
+  which is a batch of all the processed features.
+
+  NOTE: The `dataset` should contain only one element.
+
+  Now, instead of creating an iterator for the `dataset` and retrieving the
+  batch of features, the `tf.data.experimental.get_single_element()` function
+  is used to skip the iterator creation process and directly output the batch
+  of features.
+
+  This can be particularly useful when your tensor transformations are
+  expressed as `tf.data.Dataset` operations, and you want to use those
+  transformations while serving your model.
+
+  # Keras
+
+  ```python
+
+  model = ... # A pre-built or custom model
+
+  class PreprocessingModel(tf.keras.Model):
+    def __init__(self, model):
+      super().__init__(self)
+      self.model = model
+
+    @tf.function(input_signature=[...])
+    def serving_fn(self, data):
+      ds = tf.data.Dataset.from_tensor_slices(data)
+      ds = ds.map(preprocessing_fn, num_parallel_calls=BATCH_SIZE)
+      ds = ds.batch(batch_size=BATCH_SIZE)
+      return tf.argmax(
+        self.model(tf.data.experimental.get_single_element(ds)),
+        axis=-1
+      )
+
+  preprocessing_model = PreprocessingModel(model)
+  your_exported_model_dir = ... # save the model to this path.
+  tf.saved_model.save(preprocessing_model, your_exported_model_dir,
+                signatures={'serving_default': preprocessing_model.serving_fn})
+  ```
+
+  Args:
+    dataset: A `tf.data.Dataset` object containing a single element.
+
+  Returns:
+    A nested structure of `tf.Tensor` objects, corresponding to the single
+    element of `dataset`.
+
+  Raises:
+    TypeError: if `dataset` is not a `tf.data.Dataset` object.
+    InvalidArgumentError: (at runtime) if `dataset` does not contain exactly
+      one element.
+  """
+  if not isinstance(dataset, data_types.DatasetV2):
+    raise TypeError(
+        f"Invalid `dataset`. Expected a `tf.data.Dataset` object "
+        f"but got {type(dataset)}.")
+
+  return dataset.get_single_element()

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/grouping.py

@@ -0,0 +1,428 @@
+# 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.
+# ==============================================================================
+"""Grouping dataset transformations."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import structured_function
+from tensorflow.python.data.util import nest
+from tensorflow.python.data.util import structure
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_spec
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.group_by_reducer")
+def group_by_reducer(key_func, reducer):
+  """A transformation that groups elements and performs a reduction.
+
+  This transformation maps element of a dataset to a key using `key_func` and
+  groups the elements by key. The `reducer` is used to process each group; its
+  `init_func` is used to initialize state for each group when it is created, the
+  `reduce_func` is used to update the state every time an element is mapped to
+  the matching group, and the `finalize_func` is used to map the final state to
+  an output value.
+
+  Args:
+    key_func: A function mapping a nested structure of tensors
+      (having shapes and types defined by `self.output_shapes` and
+      `self.output_types`) to a scalar `tf.int64` tensor.
+    reducer: An instance of `Reducer`, which captures the reduction logic using
+      the `init_func`, `reduce_func`, and `finalize_func` functions.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    """Function from `Dataset` to `Dataset` that applies the transformation."""
+    return _GroupByReducerDataset(dataset, key_func, reducer)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.group_by_window(...)`.")
+@tf_export("data.experimental.group_by_window")
+def group_by_window(key_func,
+                    reduce_func,
+                    window_size=None,
+                    window_size_func=None):
+  """A transformation that groups windows of elements by key and reduces them.
+
+  This transformation maps each consecutive element in a dataset to a key
+  using `key_func` and groups the elements by key. It then applies
+  `reduce_func` to at most `window_size_func(key)` elements matching the same
+  key. All except the final window for each key will contain
+  `window_size_func(key)` elements; the final window may be smaller.
+
+  You may provide either a constant `window_size` or a window size determined by
+  the key through `window_size_func`.
+
+  Args:
+    key_func: A function mapping a nested structure of tensors
+      (having shapes and types defined by `self.output_shapes` and
+      `self.output_types`) to a scalar `tf.int64` tensor.
+    reduce_func: A function mapping a key and a dataset of up to `window_size`
+      consecutive elements matching that key to another dataset.
+    window_size: A `tf.int64` scalar `tf.Tensor`, representing the number of
+      consecutive elements matching the same key to combine in a single
+      batch, which will be passed to `reduce_func`. Mutually exclusive with
+      `window_size_func`.
+    window_size_func: A function mapping a key to a `tf.int64` scalar
+      `tf.Tensor`, representing the number of consecutive elements matching
+      the same key to combine in a single batch, which will be passed to
+      `reduce_func`. Mutually exclusive with `window_size`.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    ValueError: if neither or both of {`window_size`, `window_size_func`} are
+      passed.
+  """
+
+  def _apply_fn(dataset):
+    """Function from `Dataset` to `Dataset` that applies the transformation."""
+    return dataset.group_by_window(
+        key_func=key_func,
+        reduce_func=reduce_func,
+        window_size=window_size,
+        window_size_func=window_size_func)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None,
+                        "Use `tf.data.Dataset.bucket_by_sequence_length(...)`.")
+@tf_export("data.experimental.bucket_by_sequence_length")
+def bucket_by_sequence_length(element_length_func,
+                              bucket_boundaries,
+                              bucket_batch_sizes,
+                              padded_shapes=None,
+                              padding_values=None,
+                              pad_to_bucket_boundary=False,
+                              no_padding=False,
+                              drop_remainder=False):
+  """A transformation that buckets elements in a `Dataset` by length.
+
+  Elements of the `Dataset` are grouped together by length and then are padded
+  and batched.
+
+  This is useful for sequence tasks in which the elements have variable length.
+  Grouping together elements that have similar lengths reduces the total
+  fraction of padding in a batch which increases training step efficiency.
+
+  Below is an example to bucketize the input data to the 3 buckets
+  "[0, 3), [3, 5), [5, inf)" based on sequence length, with batch size 2.
+
+  >>> elements = [
+  ...   [0], [1, 2, 3, 4], [5, 6, 7],
+  ...   [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]
+
+  >>> dataset = tf.data.Dataset.from_generator(
+  ...     lambda: elements, tf.int64, output_shapes=[None])
+
+  >>> dataset = dataset.apply(
+  ...     tf.data.experimental.bucket_by_sequence_length(
+  ...         element_length_func=lambda elem: tf.shape(elem)[0],
+  ...         bucket_boundaries=[3, 5],
+  ...         bucket_batch_sizes=[2, 2, 2]))
+
+  >>> for elem in dataset.as_numpy_iterator():
+  ...   print(elem)
+  [[1 2 3 4]
+   [5 6 7 0]]
+  [[ 7  8  9 10 11  0]
+   [13 14 15 16 19 20]]
+  [[ 0  0]
+   [21 22]]
+
+  There is also a possibility to pad the dataset till the bucket boundary.
+  You can also provide which value to be used while padding the data.
+  Below example uses `-1` as padding and it also shows the input data
+  being bucketizied to two buckets "[0,3], [4,6]".
+
+  >>> elements = [
+  ...   [0], [1, 2, 3, 4], [5, 6, 7],
+  ...   [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]
+
+  >>> dataset = tf.data.Dataset.from_generator(
+  ...   lambda: elements, tf.int32, output_shapes=[None])
+
+  >>> dataset = dataset.apply(
+  ...     tf.data.experimental.bucket_by_sequence_length(
+  ...         element_length_func=lambda elem: tf.shape(elem)[0],
+  ...         bucket_boundaries=[4, 7],
+  ...         bucket_batch_sizes=[2, 2, 2],
+  ...         pad_to_bucket_boundary=True,
+  ...         padding_values=-1))
+
+  >>> for elem in dataset.as_numpy_iterator():
+  ...   print(elem)
+  [[ 0 -1 -1]
+   [ 5  6  7]]
+  [[ 1  2  3  4 -1 -1]
+   [ 7  8  9 10 11 -1]]
+  [[21 22 -1]]
+  [[13 14 15 16 19 20]]
+
+  When using `pad_to_bucket_boundary` option, it can be seen that it is
+  not always possible to maintain the bucket batch size.
+  You can drop the batches that do not maintain the bucket batch size by
+  using the option `drop_remainder`. Using the same input data as in the
+  above example you get the following result.
+
+  >>> elements = [
+  ...   [0], [1, 2, 3, 4], [5, 6, 7],
+  ...   [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]]
+
+  >>> dataset = tf.data.Dataset.from_generator(
+  ...   lambda: elements, tf.int32, output_shapes=[None])
+
+  >>> dataset = dataset.apply(
+  ...     tf.data.experimental.bucket_by_sequence_length(
+  ...         element_length_func=lambda elem: tf.shape(elem)[0],
+  ...         bucket_boundaries=[4, 7],
+  ...         bucket_batch_sizes=[2, 2, 2],
+  ...         pad_to_bucket_boundary=True,
+  ...         padding_values=-1,
+  ...         drop_remainder=True))
+
+  >>> for elem in dataset.as_numpy_iterator():
+  ...   print(elem)
+  [[ 0 -1 -1]
+   [ 5  6  7]]
+  [[ 1  2  3  4 -1 -1]
+   [ 7  8  9 10 11 -1]]
+
+  Args:
+    element_length_func: function from element in `Dataset` to `tf.int32`,
+      determines the length of the element, which will determine the bucket it
+      goes into.
+    bucket_boundaries: `list<int>`, upper length boundaries of the buckets.
+    bucket_batch_sizes: `list<int>`, batch size per bucket. Length should be
+      `len(bucket_boundaries) + 1`.
+    padded_shapes: Nested structure of `tf.TensorShape` to pass to
+      `tf.data.Dataset.padded_batch`. If not provided, will use
+      `dataset.output_shapes`, which will result in variable length dimensions
+      being padded out to the maximum length in each batch.
+    padding_values: Values to pad with, passed to
+      `tf.data.Dataset.padded_batch`. Defaults to padding with 0.
+    pad_to_bucket_boundary: bool, if `False`, will pad dimensions with unknown
+      size to maximum length in batch. If `True`, will pad dimensions with
+      unknown size to bucket boundary minus 1 (i.e., the maximum length in each
+      bucket), and caller must ensure that the source `Dataset` does not contain
+      any elements with length longer than `max(bucket_boundaries)`.
+    no_padding: `bool`, indicates whether to pad the batch features (features
+      need to be either of type `tf.sparse.SparseTensor` or of same shape).
+    drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing
+      whether the last batch should be dropped in the case it has fewer than
+      `batch_size` elements; the default behavior is not to drop the smaller
+      batch.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    ValueError: if `len(bucket_batch_sizes) != len(bucket_boundaries) + 1`.
+  """
+
+  def _apply_fn(dataset):
+    return dataset.bucket_by_sequence_length(
+        element_length_func=element_length_func,
+        bucket_boundaries=bucket_boundaries,
+        bucket_batch_sizes=bucket_batch_sizes,
+        padded_shapes=padded_shapes,
+        padding_values=padding_values,
+        pad_to_bucket_boundary=pad_to_bucket_boundary,
+        no_padding=no_padding,
+        drop_remainder=drop_remainder)
+
+  return _apply_fn
+
+
+class _GroupByReducerDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that groups its input and performs a reduction."""
+
+  def __init__(self, input_dataset, key_func, reducer):
+    """See `group_by_reducer()` for details."""
+    self._input_dataset = input_dataset
+    self._make_key_func(key_func, input_dataset)
+    self._make_init_func(reducer.init_func)
+    self._make_reduce_func(reducer.reduce_func, input_dataset)
+    self._make_finalize_func(reducer.finalize_func)
+    variant_tensor = ged_ops.experimental_group_by_reducer_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        self._key_func.function.captured_inputs,
+        self._init_func.function.captured_inputs,
+        self._reduce_func.function.captured_inputs,
+        self._finalize_func.function.captured_inputs,
+        key_func=self._key_func.function,
+        init_func=self._init_func.function,
+        reduce_func=self._reduce_func.function,
+        finalize_func=self._finalize_func.function,
+        **self._flat_structure)
+    super(_GroupByReducerDataset, self).__init__(input_dataset, variant_tensor)
+
+  def _make_key_func(self, key_func, input_dataset):
+    """Make wrapping defun for key_func."""
+    self._key_func = structured_function.StructuredFunctionWrapper(
+        key_func, self._transformation_name(), dataset=input_dataset)
+    if not self._key_func.output_structure.is_compatible_with(
+        tensor_spec.TensorSpec([], dtypes.int64)):
+      raise ValueError(
+          f"Invalid `key_func`. Expected `key_func` to return a scalar "
+          f"tf.int64 tensor, but instead `key_func` has output "
+          f"types={self._key_func.output_types} "
+          f"and shapes={self._key_func.output_shapes}."
+      )
+
+  def _make_init_func(self, init_func):
+    """Make wrapping defun for init_func."""
+    self._init_func = structured_function.StructuredFunctionWrapper(
+        init_func,
+        self._transformation_name(),
+        input_structure=tensor_spec.TensorSpec([], dtypes.int64))
+
+  def _make_reduce_func(self, reduce_func, input_dataset):
+    """Make wrapping defun for reduce_func."""
+
+    # Iteratively rerun the reduce function until reaching a fixed point on
+    # `self._state_structure`.
+    self._state_structure = self._init_func.output_structure
+    state_types = self._init_func.output_types
+    state_shapes = self._init_func.output_shapes
+    state_classes = self._init_func.output_classes
+    need_to_rerun = True
+    while need_to_rerun:
+
+      wrapped_func = structured_function.StructuredFunctionWrapper(
+          reduce_func,
+          self._transformation_name(),
+          input_structure=(self._state_structure, input_dataset.element_spec),
+          add_to_graph=False)
+
+      # Extract and validate class information from the returned values.
+      for new_state_class, state_class in zip(
+          nest.flatten(wrapped_func.output_classes),
+          nest.flatten(state_classes)):
+        if not issubclass(new_state_class, state_class):
+          raise TypeError(
+              f"Invalid `reducer`. The output class of the "
+              f"`reducer.reduce_func` {wrapped_func.output_classes}, "
+              f"does not match the class of the reduce state "
+              f"{self._state_classes}.")
+
+      # Extract and validate type information from the returned values.
+      for new_state_type, state_type in zip(
+          nest.flatten(wrapped_func.output_types), nest.flatten(state_types)):
+        if new_state_type != state_type:
+          raise TypeError(
+              f"Invalid `reducer`. The element types for the new state "
+              f"{wrapped_func.output_types} do not match the element types "
+              f"of the old state {self._init_func.output_types}."
+          )
+
+      # Extract shape information from the returned values.
+      flat_state_shapes = nest.flatten(state_shapes)
+      flat_new_state_shapes = nest.flatten(wrapped_func.output_shapes)
+      weakened_state_shapes = [
+          original.most_specific_compatible_shape(new)
+          for original, new in zip(flat_state_shapes, flat_new_state_shapes)
+      ]
+
+      need_to_rerun = False
+      for original_shape, weakened_shape in zip(flat_state_shapes,
+                                                weakened_state_shapes):
+        if original_shape.ndims is not None and (
+            weakened_shape.ndims is None or
+            original_shape.as_list() != weakened_shape.as_list()):
+          need_to_rerun = True
+          break
+
+      if need_to_rerun:
+        state_shapes = nest.pack_sequence_as(
+            self._init_func.output_shapes, weakened_state_shapes)
+        self._state_structure = structure.convert_legacy_structure(
+            state_types, state_shapes, state_classes)
+
+    self._reduce_func = wrapped_func
+    self._reduce_func.function.add_to_graph(ops.get_default_graph())
+
+  def _make_finalize_func(self, finalize_func):
+    """Make wrapping defun for finalize_func."""
+    self._finalize_func = structured_function.StructuredFunctionWrapper(
+        finalize_func,
+        self._transformation_name(),
+        input_structure=self._state_structure)
+
+  @property
+  def element_spec(self):
+    return self._finalize_func.output_structure
+
+  def _functions(self):
+    return [
+        self._key_func, self._init_func, self._reduce_func, self._finalize_func
+    ]
+
+  def _transformation_name(self):
+    return "tf.data.experimental.group_by_reducer()"
+
+
+@tf_export("data.experimental.Reducer")
+class Reducer:
+  """A reducer is used for reducing a set of elements.
+
+  A reducer is represented as a tuple of the three functions:
+  - init_func - to define initial value: key => initial state
+  - reducer_func - operation to perform on values with same key: (old state, input) => new state
+  - finalize_func - value to return in the end: state => result
+  
+  For example,
+  
+  ```
+  def init_func(_):
+    return (0.0, 0.0)
+
+  def reduce_func(state, value):
+    return (state[0] + value['features'], state[1] + 1)
+
+  def finalize_func(s, n):
+    return s / n
+
+  reducer = tf.data.experimental.Reducer(init_func, reduce_func, finalize_func)
+  ```
+  """
+
+  def __init__(self, init_func, reduce_func, finalize_func):
+    self._init_func = init_func
+    self._reduce_func = reduce_func
+    self._finalize_func = finalize_func
+
+  @property
+  def init_func(self):
+    return self._init_func
+
+  @property
+  def reduce_func(self):
+    return self._reduce_func
+
+  @property
+  def finalize_func(self):
+    return self._finalize_func

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/lookup_ops.py

@@ -0,0 +1,238 @@
+# 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.
+#==============================================================================
+"""Lookup operations."""
+
+from tensorflow.python.data.experimental.ops.cardinality import assert_cardinality
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.ops import lookup_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+def _check_table_initializer_element_spec(element_spec):
+  """Raises an error if the given table initializer element spec is invalid."""
+  base_error = ("Datasets used to initialize lookup tables must "
+                "produce elements in the form (key, value), where "
+                "the keys and values are scalar tensors. ")
+  specific_error = None
+  if len(element_spec) != 2:
+    raise ValueError(base_error + "However, the given dataset produces "
+                     f"{len(element_spec)} components instead of two "
+                     "(key, value) components. Full dataset element spec: "
+                     f"{element_spec}.")
+  if not isinstance(element_spec[0], tensor.TensorSpec):
+    raise ValueError(base_error + "However, the given dataset produces "
+                     f"non-Tensor keys of type {type(element_spec[0])}.")
+  if not isinstance(element_spec[1], tensor.TensorSpec):
+    raise ValueError(base_error + "However, the given dataset produces "
+                     f"non-Tensor values of type {type(element_spec[1])}.")
+  if element_spec[0].shape.rank not in (None, 0):
+    raise ValueError(
+        base_error + "However, the given dataset produces "
+        f"non-scalar key Tensors of rank {element_spec[0].shape.rank}.")
+  if element_spec[1].shape.rank not in (None, 0):
+    raise ValueError(
+        base_error + "However, the given dataset produces "
+        f"non-scalar value Tensors of rank {element_spec[1].shape.rank}.")
+
+
+@tf_export("data.experimental.DatasetInitializer")
+class DatasetInitializer(lookup_ops.TableInitializerBase):
+  """Creates a table initializer from a `tf.data.Dataset`.
+
+  Sample usage:
+
+  >>> keys = tf.data.Dataset.range(100)
+  >>> values = tf.data.Dataset.range(100).map(
+  ...     lambda x: tf.strings.as_string(x * 2))
+  >>> ds = tf.data.Dataset.zip((keys, values))
+  >>> init = tf.data.experimental.DatasetInitializer(ds)
+  >>> table = tf.lookup.StaticHashTable(init, "")
+  >>> table.lookup(tf.constant([0, 1, 2], dtype=tf.int64)).numpy()
+  array([b'0', b'2', b'4'], dtype=object)
+
+  Attributes:
+    dataset: A `tf.data.Dataset` object that produces tuples of scalars. The
+      first scalar is treated as a key and the second as value.
+  Raises: ValueError if `dataset` doesn't conform to specifications.
+  """
+
+  def __init__(self, dataset):
+    """Creates a table initializer from a `tf.data.Dataset`.
+
+    Args:
+      dataset: A `tf.data.Dataset` object that produces tuples of scalars. The
+        first scalar is treated as a key and the second as value.
+    Raises: ValueError if `dataset` doesn't conform to specifications.
+    Returns: A `DatasetInitializer` object
+    """
+    # Assert that the dataset element spec is a tuple of TensorSpecs where
+    # each tensor is a scalar.
+    self.dataset = dataset
+    elem_spec = self.dataset.element_spec
+    _check_table_initializer_element_spec(elem_spec)
+
+    key_type = elem_spec[0].dtype
+    value_type = elem_spec[1].dtype
+    super(DatasetInitializer, self).__init__(key_type, value_type)
+
+  def initialize(self, table):
+    lookup_ops.check_table_dtypes(table, self._key_dtype, self._value_dtype)
+    init_op = ged_ops.initialize_table_from_dataset(
+        table.resource_handle, self.dataset._variant_tensor)  # pylint: disable=protected-access
+    ops.add_to_collection(ops.GraphKeys.TABLE_INITIALIZERS, init_op)
+    return init_op
+
+
+@tf_export("data.experimental.table_from_dataset")
+def table_from_dataset(dataset=None,
+                       num_oov_buckets=0,
+                       vocab_size=None,
+                       default_value=None,
+                       hasher_spec=lookup_ops.FastHashSpec,
+                       key_dtype=dtypes.string,
+                       name=None):
+  """Returns a lookup table based on the given dataset.
+
+  This operation constructs a lookup table based on the given dataset of pairs
+  of (key, value).
+
+  Any lookup of an out-of-vocabulary token will return a bucket ID based on its
+  hash if `num_oov_buckets` is greater than zero. Otherwise it is assigned the
+  `default_value`.
+  The bucket ID range is
+  `[vocabulary size, vocabulary size + num_oov_buckets - 1]`.
+
+  Sample Usages:
+
+  >>> keys = tf.data.Dataset.range(100)
+  >>> values = tf.data.Dataset.range(100).map(
+  ...     lambda x: tf.strings.as_string(x * 2))
+  >>> ds = tf.data.Dataset.zip((keys, values))
+  >>> table = tf.data.experimental.table_from_dataset(
+  ...                               ds, default_value='n/a', key_dtype=tf.int64)
+  >>> table.lookup(tf.constant([0, 1, 2], dtype=tf.int64)).numpy()
+  array([b'0', b'2', b'4'], dtype=object)
+
+  Args:
+    dataset: A dataset containing (key, value) pairs.
+    num_oov_buckets: The number of out-of-vocabulary buckets.
+    vocab_size: Number of the elements in the vocabulary, if known.
+    default_value: The value to use for out-of-vocabulary feature values.
+      Defaults to -1.
+    hasher_spec: A `HasherSpec` to specify the hash function to use for
+      assignation of out-of-vocabulary buckets.
+    key_dtype: The `key` data type.
+    name: A name for this op (optional).
+
+  Returns:
+    The lookup table based on the given dataset.
+
+  Raises:
+    ValueError: If
+      * `dataset` does not contain pairs
+      * The 2nd item in the `dataset` pairs has a dtype which is incompatible
+        with `default_value`
+      * `num_oov_buckets` is negative
+      * `vocab_size` is not greater than zero
+      * The `key_dtype` is not integer or string
+  """
+  elem_spec = dataset.element_spec
+  _check_table_initializer_element_spec(elem_spec)
+  if default_value is None:
+    default_value = -1
+    if not (elem_spec[1].dtype.is_integer or elem_spec[1].dtype.is_floating):
+      raise ValueError("`default_value` must be specified when creating a "
+                       "table from a dataset that produces values of type "
+                       f"{elem_spec[1].dtype}.")
+  if num_oov_buckets < 0:
+    raise ValueError("`num_oov_buckets` must be greater than or equal to 0, "
+                     f"got {num_oov_buckets}.")
+  if (not isinstance(vocab_size, tensor.Tensor) and vocab_size is not None and
+      vocab_size < 1):
+    raise ValueError(f"`vocab_size` must be greater than 0, got {vocab_size}.")
+  if (not key_dtype.is_integer) and (dtypes.string != key_dtype.base_dtype):
+    raise TypeError("`key_dtype` must be either an integer or string type, "
+                    f"but got {key_dtype}")
+  if vocab_size is not None:
+    if isinstance(vocab_size, tensor.Tensor):
+      vocab_size = math_ops.cast(vocab_size, dtypes.int64)
+    dataset = dataset.take(vocab_size)
+    dataset = dataset.apply(assert_cardinality(vocab_size))
+  with ops.name_scope(name, "string_to_index"):
+    initializer = DatasetInitializer(dataset)
+    with ops.name_scope(None, "hash_table"):
+      table = lookup_ops.StaticHashTableV1(initializer, default_value)
+      if num_oov_buckets:
+        table = lookup_ops.IdTableWithHashBuckets(
+            table,
+            num_oov_buckets=num_oov_buckets,
+            hasher_spec=hasher_spec,
+            key_dtype=key_dtype)
+      return table
+
+
+@tf_export("data.experimental.index_table_from_dataset")
+def index_table_from_dataset(dataset=None,
+                             num_oov_buckets=0,
+                             vocab_size=None,
+                             default_value=-1,
+                             hasher_spec=lookup_ops.FastHashSpec,
+                             key_dtype=dtypes.string,
+                             name=None):
+  """Returns an index lookup table based on the given dataset.
+
+  This operation constructs a lookup table based on the given dataset of keys.
+
+  Any lookup of an out-of-vocabulary token will return a bucket ID based on its
+  hash if `num_oov_buckets` is greater than zero. Otherwise it is assigned the
+  `default_value`.
+  The bucket ID range is
+  `[vocabulary size, vocabulary size + num_oov_buckets - 1]`.
+
+  Sample Usages:
+
+  >>> ds = tf.data.Dataset.range(100).map(lambda x: tf.strings.as_string(x * 2))
+  >>> table = tf.data.experimental.index_table_from_dataset(
+  ...                                     ds, key_dtype=dtypes.int64)
+  >>> table.lookup(tf.constant(['0', '2', '4'], dtype=tf.string)).numpy()
+  array([0, 1, 2])
+
+  Args:
+    dataset: A dataset of keys.
+    num_oov_buckets: The number of out-of-vocabulary buckets.
+    vocab_size: Number of the elements in the vocabulary, if known.
+    default_value: The value to use for out-of-vocabulary feature values.
+      Defaults to -1.
+    hasher_spec: A `HasherSpec` to specify the hash function to use for
+      assignation of out-of-vocabulary buckets.
+    key_dtype: The `key` data type.
+    name: A name for this op (optional).
+
+  Returns:
+    The lookup table based on the given dataset.
+
+  Raises:
+    ValueError: If
+      * `num_oov_buckets` is negative
+      * `vocab_size` is not greater than zero
+      * The `key_dtype` is not integer or string
+  """
+  return table_from_dataset(dataset.enumerate().map(lambda v, k: (k, v)),
+                            num_oov_buckets, vocab_size, default_value,
+                            hasher_spec, key_dtype, name)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/map_defun.py

@@ -0,0 +1,65 @@
+# 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.
+# ==============================================================================
+"""Experimental API for optimizing `tf.data` pipelines."""
+
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.ops import gen_dataset_ops
+
+
+def map_defun(fn,
+              elems,
+              output_dtypes,
+              output_shapes,
+              max_intra_op_parallelism=1):
+  """Map a function on the list of tensors unpacked from `elems` on dimension 0.
+
+  Args:
+    fn: A function (`function.defun`) that takes a list of tensors and returns
+      another list of tensors. The output list has the same types as
+      output_dtypes. The elements of the output list have the same dimension 0
+      as `elems`, and the remaining dimensions correspond to those of
+      `fn_output_shapes`.
+    elems: A list of tensors.
+    output_dtypes: A list of dtypes corresponding to the output types of the
+      function.
+    output_shapes: A list of `TensorShape`s corresponding to the output shapes
+      from each invocation of the function on slices of inputs.
+    max_intra_op_parallelism: An integer. If positive, sets the max parallelism
+      limit of each function call to this.
+
+  Raises:
+    ValueError: if any of the inputs are malformed.
+
+  Returns:
+    A list of `Tensor` objects with the same types as `output_dtypes`.
+  """
+  if not isinstance(elems, list):
+    raise ValueError(f"`elems` must be a list of tensors, but was {elems}.")
+  if not isinstance(output_dtypes, list):
+    raise ValueError("`output_dtypes` must be a list of `tf.DType` objects, "
+                     f"but was {output_dtypes}.")
+  if not isinstance(output_shapes, list):
+    raise ValueError("`output_shapes` must be a list of `tf.TensorShape` "
+                     f"objects, but was {output_shapes}.")
+
+  concrete_fn = fn.get_concrete_function()  # pylint: disable=protected-access
+  # TODO(shivaniagrawal/rachelim): what about functions created without
+  # input_signature.
+  elems = [ops.convert_to_tensor(e) for e in elems]
+  output_shapes = [tensor_shape.TensorShape(s) for s in output_shapes]
+  return gen_dataset_ops.map_defun(elems, concrete_fn.captured_inputs,
+                                   output_dtypes, output_shapes, concrete_fn,
+                                   max_intra_op_parallelism)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/matching_files.py

@@ -0,0 +1,35 @@
+# 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.
+# ==============================================================================
+"""Experimental API for matching input filenames."""
+
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_spec
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+
+
+class MatchingFilesDataset(dataset_ops.DatasetSource):
+  """A `Dataset` that list the files according to the input patterns."""
+
+  def __init__(self, patterns):
+    self._patterns = ops.convert_to_tensor(
+        patterns, dtype=dtypes.string, name="patterns")
+    variant_tensor = ged_ops.matching_files_dataset(self._patterns)
+    super(MatchingFilesDataset, self).__init__(variant_tensor)
+
+  @property
+  def element_spec(self):
+    return tensor_spec.TensorSpec([], dtypes.string)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/scan_ops.py

@@ -0,0 +1,45 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Scan dataset transformation."""
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.scan(...) instead")
+@tf_export("data.experimental.scan")
+def scan(initial_state, scan_func):
+  """A transformation that scans a function across an input dataset.
+
+  This transformation is a stateful relative of `tf.data.Dataset.map`.
+  In addition to mapping `scan_func` across the elements of the input dataset,
+  `scan()` accumulates one or more state tensors, whose initial values are
+  `initial_state`.
+
+  Args:
+    initial_state: A nested structure of tensors, representing the initial state
+      of the accumulator.
+    scan_func: A function that maps `(old_state, input_element)` to
+      `(new_state, output_element)`. It must take two arguments and return a
+      pair of nested structures of tensors. The `new_state` must match the
+      structure of `initial_state`.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+  def _apply_fn(dataset):
+    return dataset.scan(initial_state=initial_state, scan_func=scan_func)
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/snapshot.py

@@ -0,0 +1,276 @@
+# 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.
+# ==============================================================================
+"""Dataset snapshot and related functionality."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import random_seed
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+COMPRESSION_GZIP = "GZIP"
+COMPRESSION_SNAPPY = "SNAPPY"
+COMPRESSION_NONE = None
+
+
+class _LegacySnapshotDataset(dataset_ops.UnaryUnchangedStructureDataset):
+  """A Dataset that captures a snapshot or reads from a snapshot."""
+
+  def __init__(self,
+               input_dataset,
+               path,
+               compression=None,
+               reader_path_prefix=None,
+               writer_path_prefix=None,
+               shard_size_bytes=None,
+               pending_snapshot_expiry_seconds=None,
+               num_reader_threads=None,
+               reader_buffer_size=None,
+               num_writer_threads=None,
+               writer_buffer_size=None,
+               shuffle_on_read=None,
+               shuffle_seed=None,
+               mode=None,
+               snapshot_name=None):
+
+    self._compression = compression if compression is not None else ""
+    self._reader_path_prefix = (
+        reader_path_prefix if reader_path_prefix is not None else "")
+    self._writer_path_prefix = (
+        writer_path_prefix if writer_path_prefix is not None else "")
+    self._shard_size_bytes = (
+        shard_size_bytes if shard_size_bytes is not None else -1)
+    self._pending_snapshot_expiry_seconds = (
+        pending_snapshot_expiry_seconds
+        if pending_snapshot_expiry_seconds is not None else -1)
+    self._num_reader_threads = (
+        num_reader_threads if num_reader_threads is not None else -1)
+    self._reader_buffer_size = (
+        reader_buffer_size if reader_buffer_size is not None else -1)
+    self._num_writer_threads = (
+        num_writer_threads if num_writer_threads is not None else -1)
+    self._writer_buffer_size = (
+        writer_buffer_size if writer_buffer_size is not None else -1)
+    self._shuffle_on_read = (
+        shuffle_on_read if shuffle_on_read is not None else False)
+    self._mode = (mode if mode is not None else "auto")
+    self._snapshot_name = (snapshot_name if snapshot_name is not None else "")
+
+    self._seed, self._seed2 = random_seed.get_seed(shuffle_seed)
+
+    self._input_dataset = input_dataset
+    self._path = ops.convert_to_tensor(path, dtype=dtypes.string, name="path")
+
+    variant_tensor = ged_ops.snapshot_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        path=self._path,
+        compression=self._compression,
+        reader_path_prefix=self._reader_path_prefix,
+        writer_path_prefix=self._writer_path_prefix,
+        shard_size_bytes=self._shard_size_bytes,
+        pending_snapshot_expiry_seconds=self._pending_snapshot_expiry_seconds,
+        num_reader_threads=self._num_reader_threads,
+        reader_buffer_size=self._reader_buffer_size,
+        num_writer_threads=self._num_writer_threads,
+        writer_buffer_size=self._writer_buffer_size,
+        shuffle_on_read=self._shuffle_on_read,
+        seed=self._seed,
+        seed2=self._seed2,
+        mode=self._mode,
+        snapshot_name=self._snapshot_name,
+        **self._flat_structure)
+
+    super(_LegacySnapshotDataset, self).__init__(input_dataset, variant_tensor)
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.shapshot(...)` instead.")
+def legacy_snapshot(path,
+                    compression=None,
+                    reader_path_prefix=None,
+                    writer_path_prefix=None,
+                    shard_size_bytes=None,
+                    pending_snapshot_expiry_seconds=None,
+                    num_reader_threads=None,
+                    reader_buffer_size=None,
+                    num_writer_threads=None,
+                    writer_buffer_size=None,
+                    shuffle_on_read=None,
+                    shuffle_seed=None,
+                    mode=None,
+                    snapshot_name=None):
+  """Writes to/reads from a snapshot of a dataset.
+
+  This function attempts to determine whether a valid snapshot exists at the
+  `path`, and reads from the snapshot if so. If not, it will run the
+  preprocessing pipeline as usual, and write out a snapshot of the data
+  processed for future use.
+
+  Args:
+    path: A directory where we want to save our snapshots and/or read from a
+      previously saved snapshot.
+    compression: The type of compression to apply to the Dataset. Currently
+      supports "GZIP" or None. Defaults to None (no compression).
+    reader_path_prefix: A prefix to add to the path when reading from snapshots.
+      Defaults to None.
+    writer_path_prefix: A prefix to add to the path when writing to snapshots.
+      Defaults to None.
+    shard_size_bytes: The size of each shard to be written by the snapshot
+      dataset op. Defaults to 10 GiB.
+    pending_snapshot_expiry_seconds: How long to wait (in seconds) before the
+      snapshot op considers a previously unfinished snapshot to be stale.
+    num_reader_threads: Number of threads to parallelize reading from snapshot.
+      Especially useful if compression is turned on since the decompression
+      operation tends to be intensive. Defaults to 1. If > 1, then this might
+      introduce non-determinism i.e. the order in which the elements are read
+      from the snapshot are different from the order they're written.
+    reader_buffer_size: Maximum number of elements we can prefetch reading from
+      the snapshot. Defaults to 1. Increasing this might improve performance but
+      will increase memory consumption.
+    num_writer_threads: Number of threads to parallelize writing from snapshot.
+      We'll open up `num_writer_threads` files and write to them in parallel.
+      Especially useful if compression is turned on since the compression
+      operation tends to be intensive. Defaults to 1. If > 1, then this might
+      introduce non-determinism i.e. the order in which the elements are read
+      from the upstream iterator are different from the order they're written.
+    writer_buffer_size: Maximum number of pipeline elements to fill up the
+      buffer before writing them out using `num_writer_threads`.
+    shuffle_on_read: If this is True, then the order in which examples are
+      produced when reading from a snapshot will be random. Defaults to False.
+    shuffle_seed: Optional. If shuffle_seed is set, the random number generator
+      used for shuffling (when shuffle_on_read is turned on) is seeded by the
+      given seed. Otherwise, it is seeded by a random seed that differs for
+      every run.
+    mode: The mode at which snapshot should operate. Valid options are "auto",
+      "read", "write", and "passthrough". The default mode is "auto", where the
+      snapshot op will automatically determine what mode to operate in.
+    snapshot_name: If set, use the supplied string as a named snapshot name
+      instead of introspecting the data pipeline and automatically generating a
+      unique identifier for the snapshot.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return _LegacySnapshotDataset(
+        input_dataset=dataset,
+        path=path,
+        compression=compression,
+        reader_path_prefix=reader_path_prefix,
+        writer_path_prefix=writer_path_prefix,
+        shard_size_bytes=shard_size_bytes,
+        pending_snapshot_expiry_seconds=pending_snapshot_expiry_seconds,
+        num_reader_threads=num_reader_threads,
+        reader_buffer_size=reader_buffer_size,
+        num_writer_threads=num_writer_threads,
+        writer_buffer_size=writer_buffer_size,
+        shuffle_on_read=shuffle_on_read,
+        shuffle_seed=shuffle_seed,
+        mode=mode,
+        snapshot_name=snapshot_name)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.snapshot(...)`.")
+@tf_export("data.experimental.snapshot")
+def snapshot(path, compression="AUTO", reader_func=None, shard_func=None):
+  """API to persist the output of the input dataset.
+
+  The snapshot API allows users to transparently persist the output of their
+  preprocessing pipeline to disk, and materialize the pre-processed data on a
+  different training run.
+
+  This API enables repeated preprocessing steps to be consolidated, and allows
+  re-use of already processed data, trading off disk storage and network
+  bandwidth for freeing up more valuable CPU resources and accelerator compute
+  time.
+
+  https://github.com/tensorflow/community/blob/master/rfcs/20200107-tf-data-snapshot.md
+  has detailed design documentation of this feature.
+
+  Users can specify various options to control the behavior of snapshot,
+  including how snapshots are read from and written to by passing in
+  user-defined functions to the `reader_func` and `shard_func` parameters.
+
+  `shard_func` is a user specified function that maps input elements to snapshot
+  shards.
+
+  Users may want to specify this function to control how snapshot files should
+  be written to disk. Below is an example of how a potential shard_func could
+  be written.
+
+  ```python
+  dataset = ...
+  dataset = dataset.enumerate()
+  dataset = dataset.apply(tf.data.Dataset.shapshot("/path/to/snapshot/dir",
+      shard_func=lambda x, y: x % NUM_SHARDS, ...))
+  dataset = dataset.map(lambda x, y: y)
+  ```
+
+  `reader_func` is a user specified function that accepts a single argument:
+  (1) a Dataset of Datasets, each representing a "split" of elements of the
+  original dataset. The cardinality of the input dataset matches the
+  number of the shards specified in the `shard_func` (see above). The function
+  should return a Dataset of elements of the original dataset.
+
+  Users may want specify this function to control how snapshot files should be
+  read from disk, including the amount of shuffling and parallelism.
+
+  Here is an example of a standard reader function a user can define. This
+  function enables both dataset shuffling and parallel reading of datasets:
+
+  ```python
+  def user_reader_func(datasets):
+    # shuffle the datasets splits
+    datasets = datasets.shuffle(NUM_CORES)
+    # read datasets in parallel and interleave their elements
+    return datasets.interleave(lambda x: x, num_parallel_calls=AUTOTUNE)
+
+  dataset = dataset.apply(tf.data.Dataset.shapshot("/path/to/snapshot/dir",
+      reader_func=user_reader_func))
+  ```
+
+  By default, snapshot parallelizes reads by the number of cores available on
+  the system, but will not attempt to shuffle the data.
+
+  Args:
+    path: Required. A directory to use for storing / loading the snapshot to /
+      from.
+    compression: Optional. The type of compression to apply to the snapshot
+      written to disk. Supported options are `GZIP`, `SNAPPY`, `AUTO` or None.
+      Defaults to AUTO, which attempts to pick an appropriate compression
+      algorithm for the dataset.
+    reader_func: Optional. A function to control how to read data from snapshot
+      shards.
+    shard_func: Optional. A function to control how to shard data when writing a
+      snapshot.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    """Actual dataset transformation."""
+    return dataset.snapshot(
+        path=path,
+        compression=compression,
+        reader_func=reader_func,
+        shard_func=shard_func)
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/unique.py

@@ -0,0 +1,43 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Unique element dataset transformations."""
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.unique(...)")
+@tf_export("data.experimental.unique")
+def unique():
+  """Creates a `Dataset` from another `Dataset`, discarding duplicates.
+
+  Use this transformation to produce a dataset that contains one instance of
+  each unique element in the input. For example:
+
+  ```python
+  dataset = tf.data.Dataset.from_tensor_slices([1, 37, 2, 37, 2, 1])
+
+  # Using `unique()` will drop the duplicate elements.
+  dataset = dataset.apply(tf.data.experimental.unique())  # ==> { 1, 37, 2 }
+  ```
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return dataset.unique()
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/writers.py

@@ -0,0 +1,126 @@
+# 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.
+# ==============================================================================
+"""Python wrappers for tf.data writers."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.util import convert
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_spec
+from tensorflow.python.ops import gen_experimental_dataset_ops
+from tensorflow.python.types import data as data_types
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.TFRecordWriter")
+@deprecation.deprecated(
+    None, "To write TFRecords to disk, use `tf.io.TFRecordWriter`. To save "
+    "and load the contents of a dataset, use `tf.data.experimental.save` "
+    "and `tf.data.experimental.load`")
+class TFRecordWriter:
+  """Writes a dataset to a TFRecord file.
+
+  The elements of the dataset must be scalar strings. To serialize dataset
+  elements as strings, you can use the `tf.io.serialize_tensor` function.
+
+  ```python
+  dataset = tf.data.Dataset.range(3)
+  dataset = dataset.map(tf.io.serialize_tensor)
+  writer = tf.data.experimental.TFRecordWriter("/path/to/file.tfrecord")
+  writer.write(dataset)
+  ```
+
+  To read back the elements, use `TFRecordDataset`.
+
+  ```python
+  dataset = tf.data.TFRecordDataset("/path/to/file.tfrecord")
+  dataset = dataset.map(lambda x: tf.io.parse_tensor(x, tf.int64))
+  ```
+
+  To shard a `dataset` across multiple TFRecord files:
+
+  ```python
+  dataset = ... # dataset to be written
+
+  def reduce_func(key, dataset):
+    filename = tf.strings.join([PATH_PREFIX, tf.strings.as_string(key)])
+    writer = tf.data.experimental.TFRecordWriter(filename)
+    writer.write(dataset.map(lambda _, x: x))
+    return tf.data.Dataset.from_tensors(filename)
+
+  dataset = dataset.enumerate()
+  dataset = dataset.apply(tf.data.experimental.group_by_window(
+    lambda i, _: i % NUM_SHARDS, reduce_func, tf.int64.max
+  ))
+
+  # Iterate through the dataset to trigger data writing.
+  for _ in dataset:
+    pass
+  ```
+  """
+
+  def __init__(self, filename, compression_type=None):
+    """Initializes a `TFRecordWriter`.
+
+    Args:
+      filename: a string path indicating where to write the TFRecord data.
+      compression_type: (Optional.) a string indicating what type of compression
+        to use when writing the file. See `tf.io.TFRecordCompressionType` for
+        what types of compression are available. Defaults to `None`.
+    """
+    self._filename = ops.convert_to_tensor(
+        filename, dtypes.string, name="filename")
+    self._compression_type = convert.optional_param_to_tensor(
+        "compression_type",
+        compression_type,
+        argument_default="",
+        argument_dtype=dtypes.string)
+
+  def write(self, dataset):
+    """Writes a dataset to a TFRecord file.
+
+    An operation that writes the content of the specified dataset to the file
+    specified in the constructor.
+
+    If the file exists, it will be overwritten.
+
+    Args:
+      dataset: a `tf.data.Dataset` whose elements are to be written to a file
+
+    Returns:
+      In graph mode, this returns an operation which when executed performs the
+      write. In eager mode, the write is performed by the method itself and
+      there is no return value.
+
+    Raises
+      TypeError: if `dataset` is not a `tf.data.Dataset`.
+      TypeError: if the elements produced by the dataset are not scalar strings.
+    """
+    if not isinstance(dataset, data_types.DatasetV2):
+      raise TypeError(
+          f"Invalid `dataset.` Expected a `tf.data.Dataset` object but got "
+          f"{type(dataset)}."
+      )
+    if not dataset_ops.get_structure(dataset).is_compatible_with(
+        tensor_spec.TensorSpec([], dtypes.string)):
+      raise TypeError(
+          f"Invalid `dataset`. Expected a`dataset` that produces scalar "
+          f"`tf.string` elements, but got a dataset which produces elements "
+          f"with shapes {dataset_ops.get_legacy_output_shapes(dataset)} and "
+          f"types {dataset_ops.get_legacy_output_types(dataset)}.")
+    # pylint: disable=protected-access
+    dataset = dataset._apply_debug_options()
+    return gen_experimental_dataset_ops.dataset_to_tf_record(
+        dataset._variant_tensor, self._filename, self._compression_type)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/service/__init__.py

@@ -0,0 +1,426 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""API for using the tf.data service.
+
+This module contains:
+
+1. tf.data server implementations for running the tf.data service.
+2. APIs for registering datasets with the tf.data service and reading from
+   the registered datasets.
+
+The tf.data service provides the following benefits:
+
+- Horizontal scaling of tf.data input pipeline processing to solve input
+  bottlenecks.
+- Data coordination for distributed training. Coordinated reads
+  enable all replicas to train on similar-length examples across each global
+  training step, improving step times in synchronous training.
+- Dynamic balancing of data across training replicas.
+
+>>> dispatcher = tf.data.experimental.service.DispatchServer()
+>>> dispatcher_address = dispatcher.target.split("://")[1]
+>>> worker = tf.data.experimental.service.WorkerServer(
+...     tf.data.experimental.service.WorkerConfig(
+...         dispatcher_address=dispatcher_address))
+>>> dataset = tf.data.Dataset.range(10)
+>>> dataset = dataset.apply(tf.data.experimental.service.distribute(
+...     processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+...     service=dispatcher.target))
+>>> print(list(dataset.as_numpy_iterator()))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+## Setup
+
+This section goes over how to set up the tf.data service.
+
+### Run tf.data servers
+
+The tf.data service consists of one dispatch server and `n` worker servers.
+tf.data servers should be brought up alongside your training jobs, then brought
+down when the jobs are finished.
+Use `tf.data.experimental.service.DispatchServer` to start a dispatch server,
+and `tf.data.experimental.service.WorkerServer` to start worker servers. Servers
+can be run in the same process for testing purposes, or scaled up on separate
+machines.
+
+See https://github.com/tensorflow/ecosystem/tree/master/data_service for an
+example of using Google Kubernetes Engine (GKE) to manage the tf.data service.
+Note that the server implementation in
+[tf_std_data_server.py](https://github.com/tensorflow/ecosystem/blob/master/data_service/tf_std_data_server.py)
+is not GKE-specific, and can be used to run the tf.data service in other
+contexts.
+
+### Custom ops
+
+If your dataset uses custom ops, these ops need to be made available to tf.data
+servers by calling
+[load_op_library](https://www.tensorflow.org/api_docs/python/tf/load_op_library)
+from the dispatcher and worker processes at startup.
+
+## Usage
+
+Users interact with tf.data service by programmatically registering their
+datasets with tf.data service, then creating datasets that read from the
+registered datasets. The
+[register_dataset](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/register_dataset)
+function registers a dataset, then the
+[from_dataset_id](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/from_dataset_id)
+function creates a new dataset which reads from the registered dataset.
+The
+[distribute](https://www.tensorflow.org/api_docs/python/tf/data/experimental/service/distribute)
+function wraps `register_dataset` and `from_dataset_id` into a single convenient
+transformation which registers its input dataset and then reads from it.
+`distribute` enables tf.data service to be used with a one-line code change.
+However, it assumes that the dataset is created and consumed by the same entity
+and this assumption might not always be valid or desirable. In particular, in
+certain scenarios, such as distributed training, it might be desirable to
+decouple the creation and consumption of the dataset (via `register_dataset`
+and `from_dataset_id` respectively) to avoid having to create the dataset on
+each of the training workers.
+
+### Example
+
+#### `distribute`
+
+To use the `distribute` transformation, apply the transformation after the
+prefix of your input pipeline that you would like to be executed using tf.data
+service (typically at the end).
+
+```
+dataset = ...  # Define your dataset here.
+# Move dataset processing from the local machine to the tf.data service
+dataset = dataset.apply(
+    tf.data.experimental.service.distribute(
+        processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+        service=FLAGS.tf_data_service_address,
+        job_name="shared_job"))
+# Any transformations added after `distribute` will be run on the local machine.
+dataset = dataset.prefetch(1)
+```
+
+The above code will create a tf.data service "job", which iterates through the
+dataset to generate data. To share the data from a job across multiple clients
+(e.g. when using TPUStrategy or MultiWorkerMirroredStrategy), set a common
+`job_name` across all clients.
+
+#### `register_dataset` and `from_dataset_id`
+
+`register_dataset` registers a dataset with the tf.data service, returning a
+dataset id for the registered dataset. `from_dataset_id` creates a dataset that
+reads from the registered dataset. These APIs can be used to reduce dataset
+building time for distributed training. Instead of building the dataset on all
+training workers, we can build the dataset just once and then register the
+dataset using `register_dataset`. Then all workers can call `from_dataset_id`
+without needing to build the dataset themselves.
+
+```
+dataset = ...  # Define your dataset here.
+dataset_id = tf.data.experimental.service.register_dataset(
+    service=FLAGS.tf_data_service_address,
+    dataset=dataset)
+# Use `from_dataset_id` to create per-worker datasets.
+per_worker_datasets = {}
+for worker in workers:
+  per_worker_datasets[worker] = tf.data.experimental.service.from_dataset_id(
+      processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+      service=FLAGS.tf_data_service_address,
+      dataset_id=dataset_id,
+      job_name="shared_job")
+```
+
+### Processing Modes
+
+`processing_mode` specifies how to shard a dataset among tf.data service
+workers. tf.data service supports `OFF`, `DYNAMIC`, `FILE`, `DATA`,
+`FILE_OR_DATA`, `HINT` sharding policies.
+
+OFF: No sharding will be performed. The entire input dataset will be processed
+independently by each of the tf.data service workers. For this reason, it is
+important to shuffle data (e.g. filenames) non-deterministically, so that each
+worker will process the elements of the dataset in a different order. This mode
+can be used to distribute datasets that aren't splittable.
+
+If a worker is added or restarted during ShardingPolicy.OFF processing, the
+worker will instantiate a new copy of the dataset and begin producing data from
+the beginning.
+
+#### Dynamic Sharding
+
+DYNAMIC: In this mode, tf.data service divides the dataset into two components:
+a source component that generates "splits" such as filenames, and a processing
+component that takes splits and outputs dataset elements. The source component
+is executed in a centralized fashion by the tf.data service dispatcher, which
+generates different splits of input data. The processing component is executed
+in a parallel fashion by the tf.data service workers, each operating on a
+different set of input data splits.
+
+For example, consider the following dataset:
+
+```
+dataset = tf.data.Dataset.from_tensor_slices(filenames)
+dataset = dataset.interleave(TFRecordDataset)
+dataset = dataset.map(preprocess_fn)
+dataset = dataset.batch(batch_size)
+dataset = dataset.apply(
+    tf.data.experimental.service.distribute(
+        processing_mode=tf.data.experimental.service.ShardingPolicy.DYNAMIC,
+        ...))
+```
+
+The `from_tensor_slices` will be run on the dispatcher, while the `interleave`,
+`map`, and `batch` will be run on tf.data service workers. The workers will pull
+filenames from the dispatcher for processing. To process a dataset with
+dynamic sharding, the dataset must have a splittable source, and all of
+its transformations must be compatible with splitting. While most sources and
+transformations support splitting, there are exceptions, such as custom datasets
+which may not implement the splitting API. Please file a Github issue if you
+would like to use distributed epoch processing for a currently unsupported
+dataset source or transformation.
+
+If no workers are restarted during training, dynamic sharding mode will visit
+every example exactly once. If workers are restarted during training, the splits
+they were processing will not be fully visited. The dispatcher maintains a
+cursor through the dataset's splits. Assuming fault tolerance is enabled (See
+"Fault Tolerance" below), the dispatcher will store cursor state in write-ahead
+logs so that the cursor can be restored in case the dispatcher is restarted
+mid-training. This provides an at-most-once visitation guarantee in the presence
+of server restarts.
+
+#### Static Sharding
+
+The following are static sharding policies. The semantics are similar to
+`tf.data.experimental.AutoShardPolicy`. These policies require:
+
+  * The tf.data service cluster is configured with a fixed list of workers
+    in DispatcherConfig.
+  * Each client only reads from the local tf.data service worker.
+
+If a worker is restarted while performing static sharding, the worker will
+begin processing its shard again from the beginning.
+
+FILE: Shards by input files (i.e. each worker will get a fixed set of files to
+process). When this option is selected, make sure that there is at least as
+many files as workers. If there are fewer input files than workers, a runtime
+error will be raised.
+
+DATA: Shards by elements produced by the dataset. Each worker will process the
+whole dataset and discard the portion that is not for itself. Note that for
+this mode to correctly partition the dataset elements, the dataset needs to
+produce elements in a deterministic order.
+
+FILE_OR_DATA: Attempts FILE-based sharding, falling back to DATA-based
+sharding on failure.
+
+HINT: Looks for the presence of `shard(SHARD_HINT, ...)` which is treated as a
+placeholder to replace with `shard(num_workers, worker_index)`.
+
+For backwards compatibility, `processing_mode` may also be set to the strings
+`"parallel_epochs"` or `"distributed_epoch"`, which are respectively equivalent
+to `ShardingPolicy.OFF` and `ShardingPolicy.DYNAMIC`.
+
+### Coordinated Data Read
+
+By default, when multiple consumers read from the same job, they receive data on
+a first-come first-served basis. In some use cases, it is advantageous to
+coordinate the consumers. At each step, consumers read data from the same
+worker.
+
+For example, the tf.data service can be used to coordinate example sizes across
+a cluster during synchronous training, so that during each step all replicas
+train on similar-sized elements. To achieve this, define a dataset which
+generates rounds of `num_consumers` consecutive similar-sized batches, then
+enable coordinated reads by setting `consumer_index` and `num_consumers`.
+
+NOTE: To keep consumers in sync, coordinated reads require that the dataset have
+infinite cardinality. You can get this by adding `.repeat()` at the end of the
+dataset definition.
+
+### Jobs
+
+A tf.data service "job" refers to the process of reading from a dataset managed
+by the tf.data service, using one or more data consumers. Jobs are created when
+iterating over datasets that read from tf.data service. The data produced by a
+job is determined by (1) dataset associated with the job and (2) the job's
+processing mode. For example, if a job is created for the dataset
+`Dataset.range(5)`, and the processing mode is `ShardingPolicy.OFF`, each
+tf.data worker will produce the elements `{0, 1, 2, 3, 4}` for the job,
+resulting in the
+job producing `5 * num_workers` elements. If the processing mode is
+`ShardingPolicy.DYNAMIC`, the job will only produce `5` elements.
+
+One or more consumers can consume data from a job. By default, jobs are
+"anonymous", meaning that only the consumer which created the job can read from
+it. To share the output of a job across multiple consumers, you can set a common
+`job_name`.
+
+### Fault Tolerance
+
+By default, the tf.data dispatch server stores its state in-memory, making it a
+single point of failure during training. To avoid this, pass
+`fault_tolerant_mode=True` when creating your `DispatchServer`. Dispatcher
+fault tolerance requires `work_dir` to be configured and accessible from the
+dispatcher both before and after restart (e.g. a GCS path). With fault tolerant
+mode enabled, the dispatcher will journal its state to the work directory so
+that no state is lost when the dispatcher is restarted.
+
+WorkerServers may be freely restarted, added, or removed during training. At
+startup, workers will register with the dispatcher and begin processing all
+outstanding jobs from the beginning.
+
+### Usage with tf.distribute
+
+tf.distribute is the TensorFlow API for distributed training. There are
+several ways to use tf.data with tf.distribute:
+`strategy.experimental_distribute_dataset`,
+`strategy.distribute_datasets_from_function`, and (for PSStrategy)
+`coordinator.create_per_worker_dataset`. The following sections give code
+examples for each.
+
+In general we recommend using
+`tf.data.experimental.service.{register_dataset,from_dataset_id}` over
+`tf.data.experimental.service.distribute` for two reasons:
+
+- The dataset only needs to be constructed and optimized once, instead of once
+  per worker. This can significantly reduce startup time, because the current
+  `experimental_distribute_dataset` and `distribute_datasets_from_function`
+  implementations create and optimize worker datasets sequentially.
+- If a dataset depends on lookup tables or variables that are only present on
+  one host, the dataset needs to be registered from that host. Typically this
+  only happens when resources are placed on the chief or worker 0. Registering
+  the dataset from the chief will avoid issues with depending on remote
+  resources.
+
+#### strategy.experimental_distribute_dataset
+
+Nothing special is required when using
+`strategy.experimental_distribute_dataset`, just apply `register_dataset` and
+`from_dataset_id` as above, making sure to specify a `job_name` so that all
+workers consume from the same tf.data service job.
+
+```
+dataset = ...  # Define your dataset here.
+dataset_id = tf.data.experimental.service.register_dataset(
+    service=FLAGS.tf_data_service_address,
+    dataset=dataset)
+dataset = tf.data.experimental.service.from_dataset_id(
+    processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+    service=FLAGS.tf_data_service_address,
+    dataset_id=dataset_id,
+    job_name="shared_job")
+
+dataset = strategy.experimental_distribute_dataset(dataset)
+```
+
+#### strategy.distribute_datasets_from_function
+
+First, make sure the dataset produced by the `dataset_fn` does not depend on the
+`input_context` for the training worker on which it is run. Instead of each
+worker building its own (sharded) dataset, one worker should register an
+unsharded dataset, and the remaining workers should consume data from that
+dataset.
+
+```
+dataset = dataset_fn()
+dataset_id = tf.data.experimental.service.register_dataset(
+    service=FLAGS.tf_data_service_address,
+    dataset=dataset)
+
+def new_dataset_fn(input_context):
+  del input_context
+  return tf.data.experimental.service.from_dataset_id(
+      processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+      service=FLAGS.tf_data_service_address,
+      dataset_id=dataset_id,
+      job_name="shared_job")
+
+dataset = strategy.distribute_datasets_from_function(new_dataset_fn)
+```
+
+#### coordinator.create_per_worker_dataset
+
+`create_per_worker_dataset` works the same as
+`distribute_datasets_from_function`.
+
+```
+dataset = dataset_fn()
+dataset_id = tf.data.experimental.service.register_dataset(
+    service=FLAGS.tf_data_service_address,
+    dataset=dataset)
+
+def new_dataset_fn(input_context):
+  del input_context
+  return tf.data.experimental.service.from_dataset_id(
+      processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+      service=FLAGS.tf_data_service_address,
+      dataset_id=dataset_id,
+      job_name="shared_job")
+
+dataset = coordinator.create_per_worker_dataset(new_dataset_fn)
+```
+
+### Sharing tf.data service with concurrent trainers
+
+If you run multiple trainers concurrently using the same training data, it could
+save resources to cache the data in one tf.data service cluster and share the
+cluster with the trainers. For example, if you use Vizier to tune
+hyperparameters, the Vizier jobs can run concurrently and share one tf.data
+service cluster.
+
+To enable this feature, each trainer needs to generate a unique trainer ID, and
+you pass the trainer ID to `tf.data.experimental.service.distribute`. Once a job
+has consumed data, the data remains in the cache and is re-used by jobs with
+different `trainer_id`s. Requests with the same `trainer_id` do not re-use data.
+For example:
+
+```
+dataset = expensive_computation()
+dataset = dataset.apply(tf.data.experimental.service.distribute(
+    processing_mode=tf.data.experimental.service.ShardingPolicy.OFF,
+    service=FLAGS.tf_data_service_address,
+    job_name="job",
+    cross_trainer_cache=data_service_ops.CrossTrainerCache(
+        trainer_id=trainer_id())))
+```
+
+tf.data service uses a sliding-window cache to store shared data. When one
+trainer consumes data, the data remains in the cache. When other trainers need
+data, they can get data from the cache instead of repeating the expensive
+computation. The cache has a bounded size, so some workers may not read the full
+dataset. To ensure all the trainers get sufficient training data, we require the
+input dataset to be infinite. This can be achieved, for example, by repeating
+the dataset and performing random augmentation on the training instances.
+
+## Limitations
+
+- Python-based data processing: Datasets which use Python-based data processing
+  (e.g. `tf.py_function`, `tf.numpy_function`, or
+  `tf.data.Dataset.from_generator`) are currently not supported.
+- Non-Serializable Resources: Datasets may only depend on TF resources that
+  support serialization. Serialization is currently supported for lookup
+  tables and variables. If your dataset depends on a TF resource that cannot be
+  serialized, please file a Github issue.
+- Remote Resources: If a dataset depends on a resource, the dataset must be
+  registered from the same process that created the resource (e.g. the "chief"
+  job of ParameterServerStrategy).
+"""
+
+from tensorflow.python.data.experimental.ops.data_service_ops import distribute
+from tensorflow.python.data.experimental.ops.data_service_ops import from_dataset_id
+from tensorflow.python.data.experimental.ops.data_service_ops import register_dataset
+from tensorflow.python.data.experimental.ops.data_service_ops import ShardingPolicy
+from tensorflow.python.data.experimental.service.server_lib import DispatcherConfig
+from tensorflow.python.data.experimental.service.server_lib import DispatchServer
+from tensorflow.python.data.experimental.service.server_lib import WorkerConfig
+from tensorflow.python.data.experimental.service.server_lib import WorkerServer

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/service/_pywrap_server_lib.pyi

@@ -0,0 +1,54 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+from typing import Any
+
+class DispatchGrpcDataServer:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def bound_port(self) -> int: ...
+    def join(self) -> None: ...
+    def num_workers(self) -> int: ...
+    def snapshot_streams(self, *args, **kwargs) -> Any: ...
+    def start(self) -> Status: ...
+    def stop(self) -> None: ...
+
+class SnapshotStreamInfoWrapper:
+    def __init__(self) -> None: ...
+    @property
+    def index(self) -> int: ...
+    @property
+    def state(self) -> int: ...
+
+class SnapshotTaskProgressWrapper:
+    def __init__(self) -> None: ...
+    @property
+    def completed(self) -> bool: ...
+    @property
+    def snapshot_task_base_path(self) -> bytes: ...
+    @property
+    def snapshot_task_stream_index(self) -> int: ...
+
+class WorkerGrpcDataServer:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def bound_port(self) -> int: ...
+    def join(self) -> None: ...
+    def num_tasks(self) -> int: ...
+    def snapshot_task_progresses(self, *args, **kwargs) -> Any: ...
+    def start(self) -> Status: ...
+    def stop(self) -> None: ...
+
+def TF_DATA_GetDataServiceMetadataByID(*args, **kwargs) -> Any: ...
+def TF_DATA_NewDispatchServer(arg0: str) -> DispatchGrpcDataServer: ...
+def TF_DATA_NewWorkerServer(arg0: str) -> WorkerGrpcDataServer: ...