Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/LICENSE

@@ -0,0 +1,251 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
+
+## Some of TensorFlow's code is derived from Caffe, which is subject to the following copyright notice:
+
+COPYRIGHT
+
+All contributions by the University of California:
+
+Copyright (c) 2014, The Regents of the University of California (Regents)
+All rights reserved.
+
+All other contributions:
+
+Copyright (c) 2014, the respective contributors
+All rights reserved.
+
+Caffe uses a shared copyright model: each contributor holds copyright over
+their contributions to Caffe. The project versioning records all such
+contribution and copyright details. If a contributor wants to further mark
+their specific copyright on a particular contribution, they should indicate
+their copyright solely in the commit message of the change when it is
+committed.
+
+LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+CONTRIBUTION AGREEMENT
+
+By contributing to the BVLC/caffe repository through pull-request, comment,
+or otherwise, the contributor releases their content to the
+license and copyright terms herein.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: tensorflow
+Version: 2.15.1
+Summary: TensorFlow is an open source machine learning framework for everyone.
+Home-page: https://www.tensorflow.org/
+Download-URL: https://github.com/tensorflow/tensorflow/tags
+Author: Google Inc.
+Author-email: packages@tensorflow.org
+License: Apache 2.0
+Keywords: tensorflow tensor machine learning
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: GPU :: NVIDIA CUDA :: 11.8
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: absl-py (>=1.0.0)
+Requires-Dist: astunparse (>=1.6.0)
+Requires-Dist: flatbuffers (>=23.5.26)
+Requires-Dist: gast (!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1)
+Requires-Dist: google-pasta (>=0.1.1)
+Requires-Dist: h5py (>=2.9.0)
+Requires-Dist: libclang (>=13.0.0)
+Requires-Dist: ml-dtypes (~=0.3.1)
+Requires-Dist: numpy (<2.0.0,>=1.23.5)
+Requires-Dist: opt-einsum (>=2.3.2)
+Requires-Dist: packaging
+Requires-Dist: protobuf (!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3)
+Requires-Dist: setuptools
+Requires-Dist: six (>=1.12.0)
+Requires-Dist: termcolor (>=1.1.0)
+Requires-Dist: typing-extensions (>=3.6.6)
+Requires-Dist: wrapt (<1.15,>=1.11.0)
+Requires-Dist: tensorflow-io-gcs-filesystem (>=0.23.1)
+Requires-Dist: grpcio (<2.0,>=1.24.3)
+Requires-Dist: tensorboard (<2.16,>=2.15)
+Requires-Dist: tensorflow-estimator (<2.16,>=2.15.0)
+Requires-Dist: keras (<2.16,>=2.15.0)
+Requires-Dist: tensorflow-cpu-aws (==2.15.1) ; platform_system == "Linux" and (platform_machine == "arm64" or platform_machine == "aarch64")
+Requires-Dist: tensorflow-intel (==2.15.1) ; platform_system == "Windows"
+Provides-Extra: and-cuda
+Requires-Dist: nvidia-cublas-cu12 (==12.2.5.6) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cuda-cupti-cu12 (==12.2.142) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cuda-nvcc-cu12 (==12.2.140) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cuda-nvrtc-cu12 (==12.2.140) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cuda-runtime-cu12 (==12.2.140) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cudnn-cu12 (==8.9.4.25) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cufft-cu12 (==11.0.8.103) ; extra == 'and-cuda'
+Requires-Dist: nvidia-curand-cu12 (==10.3.3.141) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cusolver-cu12 (==11.5.2.141) ; extra == 'and-cuda'
+Requires-Dist: nvidia-cusparse-cu12 (==12.1.2.141) ; extra == 'and-cuda'
+Requires-Dist: nvidia-nccl-cu12 (==2.16.5) ; extra == 'and-cuda'
+Requires-Dist: nvidia-nvjitlink-cu12 (==12.2.140) ; extra == 'and-cuda'
+
+[![Python](https://img.shields.io/pypi/pyversions/tensorflow.svg?style=plastic)](https://badge.fury.io/py/tensorflow)
+[![PyPI](https://badge.fury.io/py/tensorflow.svg)](https://badge.fury.io/py/tensorflow)
+
+TensorFlow is an open source software library for high performance numerical
+computation. Its flexible architecture allows easy deployment of computation
+across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
+of servers to mobile and edge devices.
+
+Originally developed by researchers and engineers from the Google Brain team
+within Google's AI organization, it comes with strong support for machine
+learning and deep learning and the flexible numerical computation core is used
+across many other scientific domains. TensorFlow is licensed under [Apache
+2.0](https://github.com/tensorflow/tensorflow/blob/master/LICENSE).

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+estimator_ckpt_converter = tensorflow_estimator.python.estimator.tools.checkpoint_converter:main
+import_pb_to_tensorboard = tensorflow.python.tools.import_pb_to_tensorboard:main
+saved_model_cli = tensorflow.python.tools.saved_model_cli:main
+tensorboard = tensorboard.main:run_main
+tf_upgrade_v2 = tensorflow.tools.compatibility.tf_upgrade_v2_main:main
+tflite_convert = tensorflow.lite.python.tflite_convert:main
+toco = tensorflow.lite.python.tflite_convert:main
+toco_from_protos = tensorflow.lite.toco.python.toco_from_protos:main

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow-2.15.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+tensorflow
+third_party

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/client/client.py

@@ -0,0 +1,438 @@
+# 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.
+# ==============================================================================
+"""Cloud TPU Client."""
+
+from concurrent import futures
+import datetime
+import json
+import logging
+import os
+import time
+import urllib
+
+from absl import flags
+
+_GOOGLE_API_CLIENT_INSTALLED = True
+try:
+  from googleapiclient import discovery  # pylint: disable=g-import-not-at-top
+  from oauth2client import client  # pylint: disable=g-import-not-at-top
+except ImportError:
+  _GOOGLE_API_CLIENT_INSTALLED = False
+
+FLAGS = flags.FLAGS
+
+flags.DEFINE_bool('runtime_oom_exit', True,
+                  'Exit the script when the TPU runtime is OOM.')
+flags.DEFINE_bool('hbm_oom_exit', True,
+                  'Exit the script when the TPU HBM is OOM.')
+
+_GKE_ENV_VARIABLE = 'KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS'
+_DEFAULT_TPUCONFIG_VARIABLE = 'TPU_CONFIG'
+_ENDPOINTS_SEPARATOR = ','
+_DEFAULT_ENV_VARIABLE = 'TPU_NAME'
+_DISCOVERY_SERVICE_URL_ENV_VARIABLE = 'TPU_API_DISCOVERY_URL'
+_GCE_METADATA_URL_ENV_VARIABLE = 'GCE_METADATA_IP'
+_GCE_METADATA_ENDPOINT_ENV_VARIABLE = 'GCE_METADATA_HOST'
+_DEFAULT_ENDPOINT_PORT = '8470'
+_OOM_EVENT_COOL_TIME_SEC = 90
+_VERSION_SWITCHER_ENDPOINT = 'http://{}:8475/requestversion'
+
+
+def _utcnow():
+  """A wrapper function around datetime.datetime.utcnow.
+
+  This function is created for unit testing purpose. It's not easy to do
+  StubOutWithMock with datetime.datetime package.
+
+  Returns:
+    datetime.datetime
+  """
+  return datetime.datetime.utcnow()
+
+
+def _environment_discovery_url():
+  return os.environ.get(_DISCOVERY_SERVICE_URL_ENV_VARIABLE)
+
+
+def _gce_metadata_endpoint():
+  endpoint = os.environ.get(_GCE_METADATA_ENDPOINT_ENV_VARIABLE)
+  if not endpoint:
+    endpoint = os.environ.get(
+        _GCE_METADATA_URL_ENV_VARIABLE, 'metadata.google.internal'
+    )
+  return 'http://' + endpoint
+
+
+def _request_compute_metadata(path):
+  req = urllib.request.Request(
+      '%s/computeMetadata/v1/%s' % (_gce_metadata_endpoint(), path),
+      headers={'Metadata-Flavor': 'Google'})
+  resp = urllib.request.urlopen(req)
+  return _as_text(resp.read())
+
+
+def _environment_var_to_network_endpoints(endpoints):
+  """Yields a dict with ip address and port."""
+  for endpoint in endpoints.split(','):
+    grpc_prefix = 'grpc://'
+    if endpoint.startswith(grpc_prefix):
+      endpoint = endpoint.split(grpc_prefix)[1]
+    parts = endpoint.split(':')
+    ip_address = parts[0]
+    port = _DEFAULT_ENDPOINT_PORT
+    if len(parts) > 1:
+      port = parts[1]
+    yield {
+        'ipAddress': ip_address,
+        'port': port
+    }
+
+
+def _get_tpu_node_config():
+  tpu_config_env = os.environ.get(_DEFAULT_TPUCONFIG_VARIABLE)
+  if tpu_config_env:
+    return json.loads(tpu_config_env)
+  return None
+
+
+def _get_tpu_name(tpu):
+  if tpu:
+    return tpu
+
+  for e in [_GKE_ENV_VARIABLE, _DEFAULT_ENV_VARIABLE]:
+    if e in os.environ:
+      return os.environ[e]
+  return None
+
+
+def _as_text(s):
+  if isinstance(s, bytes):
+    return s.decode('utf-8')
+  return s
+
+
+class Client:
+  """Client for working with the Cloud TPU API.
+
+  This client is intended to be used for resolving tpu name to ip addresses.
+
+  It's recommended to use this library as a contextlib to utilize all
+  functionality.
+  """
+
+  def __init__(self,
+               tpu=None,
+               zone=None,
+               project=None,
+               credentials='default',
+               service=None,
+               discovery_url=None):
+    if isinstance(tpu, list):
+      if not tpu:
+        raise ValueError('At least one TPU must be specified.')
+      if len(tpu) != 1:
+        raise NotImplementedError(
+            'Using multiple TPUs in a single session is not yet implemented')
+      tpu = tpu[0]
+
+    tpu = _get_tpu_name(tpu)
+
+    if tpu is None:
+      tpu_node_config = _get_tpu_node_config()
+      if tpu_node_config:
+        tpu = tpu_node_config.get('tpu_node_name')
+        project = project or tpu_node_config.get('project')
+        zone = zone or tpu_node_config.get('zone')
+      else:
+        raise ValueError('Please provide a TPU Name to connect to.')
+
+    self._tpu = _as_text(tpu)
+
+    self._use_api = not self._tpu.startswith('grpc://')
+    self._service = service
+
+    self._credentials = None
+    self._project = None
+    self._zone = None
+    self._discovery_url = None
+    if self._use_api:
+      if credentials != 'default':
+        self._credentials = credentials
+      # Automatically detect project and zone if unspecified.
+      if project:
+        self._project = _as_text(project)
+      else:
+        self._project = _request_compute_metadata('project/project-id')
+      if zone:
+        self._zone = _as_text(zone)
+      else:
+        zone_path = _request_compute_metadata('instance/zone')
+        self._zone = zone_path.split('/')[-1]
+      self._discovery_url = _environment_discovery_url() or discovery_url
+
+  def _symptom_msg(self, msg):
+    """Return the structured Symptom message."""
+    return 'Symptom: ' + msg
+
+  def _oom_event(self, symptoms):
+    """Check if a runtime OOM event is reported."""
+    if not symptoms:
+      return False
+    for symptom in reversed(symptoms):
+      if symptom['symptomType'] != 'OUT_OF_MEMORY':
+        continue
+      oom_datetime_str = symptom['createTime'].split('.')[0]
+      oom_datetime = datetime.datetime.strptime(oom_datetime_str,
+                                                '%Y-%m-%dT%H:%M:%S')
+      time_diff = _utcnow() - oom_datetime
+      if time_diff < datetime.timedelta(seconds=_OOM_EVENT_COOL_TIME_SEC):
+        logging.warning(
+            self._symptom_msg(
+                'a recent runtime OOM has occurred ~{} seconds ago. The model '
+                'script will terminate automatically. To prevent future OOM '
+                'events, please consider reducing the model size. To disable this '
+                'behavior, set flag --runtime_oom_exit=false when starting the '
+                'script.'.format(time_diff.seconds)))
+        return True
+    return False
+
+  def _hbm_oom_event(self, symptoms):
+    """Check if a HBM OOM event is reported."""
+    if not symptoms:
+      return False
+    for symptom in reversed(symptoms):
+      if symptom['symptomType'] != 'HBM_OUT_OF_MEMORY':
+        continue
+      oom_datetime_str = symptom['createTime'].split('.')[0]
+      oom_datetime = datetime.datetime.strptime(oom_datetime_str,
+                                                '%Y-%m-%dT%H:%M:%S')
+      time_diff = _utcnow() - oom_datetime
+      if time_diff < datetime.timedelta(seconds=_OOM_EVENT_COOL_TIME_SEC):
+        logging.warning(
+            self._symptom_msg(
+                'a recent HBM OOM has occurred ~{} seconds ago. The model '
+                'script will terminate automatically. To prevent future HBM OOM '
+                'events, please consider reducing the model size. To disable this '
+                'behavior, set flag --hbm_oom_exit=false when starting the '
+                'script.'.format(time_diff.seconds)))
+        return True
+    return False
+
+  def _tpu_service(self):
+    """Creates a new Cloud TPU API object.
+
+    This works around an issue where the underlying HTTP connection sometimes
+    times out when the script has been running for too long. Other methods in
+    this object call this method to get a new API object whenever they need
+    to communicate with the Cloud API.
+
+    Raises:
+      RuntimeError: If the dependent Python packages are missing.
+
+    Returns:
+      A Google Cloud TPU API object.
+    """
+    if self._service:
+      return self._service
+
+    if not _GOOGLE_API_CLIENT_INSTALLED:
+      raise RuntimeError('Missing runtime dependency on the Google API client. '
+                         'Run `pip install cloud-tpu-client` to fix.')
+
+    credentials = self._credentials
+    if credentials is None or credentials == 'default':
+      credentials = client.GoogleCredentials.get_application_default()
+
+    if self._discovery_url:
+      return discovery.build(
+          'tpu',
+          'v1',
+          credentials=credentials,
+          discoveryServiceUrl=self._discovery_url,
+          cache_discovery=False)
+    else:
+      return discovery.build(
+          'tpu', 'v1', credentials=credentials, cache_discovery=False)
+
+  def _full_name(self):
+    """Returns the full Cloud name for this TPU."""
+    return 'projects/%s/locations/%s/nodes/%s' % (
+        self._project, self._zone, self._tpu)
+
+  def _fetch_cloud_tpu_metadata(self):
+    """Returns the TPU metadata object from the TPU Get API call."""
+    service = self._tpu_service()
+    try:
+      r = service.projects().locations().nodes().get(name=self._full_name())
+      return r.execute()
+    except Exception as e:
+      raise ValueError("Could not lookup TPU metadata from name '%s'. Please "
+                       'doublecheck the tpu argument in the TPUClusterResolver '
+                       'constructor. Exception: %s' % (self._tpu, e))
+
+  def _get_tpu_property(self, key):
+    if self._use_api:
+      metadata = self._fetch_cloud_tpu_metadata()
+      return metadata.get(key)
+
+    return None
+
+  def __enter__(self):
+    self._open = True
+
+  def __exit__(self, type, value, traceback):  # pylint: disable=redefined-builtin
+    del type, value, traceback
+
+  def recoverable(self):
+    """Returns true if the TPU is in a state where training should eventually resume.
+
+    If false the TPU is in a unrecoverable state and should be recreated.
+    """
+    state = self.state()
+    symptoms = self.symptoms()
+    if state and state in ['TERMINATED', 'PREEMPTED']:
+      return False
+    elif FLAGS.runtime_oom_exit and self._oom_event(symptoms):
+      return False
+    elif FLAGS.hbm_oom_exit and self._hbm_oom_event(symptoms):
+      return False
+    return True
+
+  def symptoms(self):
+    """Return Cloud TPU Symptoms of the TPU."""
+    return self._get_tpu_property('symptoms')
+
+  def state(self):
+    """Return state of the TPU."""
+    return self._get_tpu_property('state')
+
+  def health(self):
+    """Return health of the TPU."""
+    return self._get_tpu_property('health')
+
+  def runtime_version(self):
+    """Return runtime version of the TPU."""
+
+    if not self._use_api:
+      # Fallback on getting version directly from TPU.
+      url = _VERSION_SWITCHER_ENDPOINT.format(
+          self.network_endpoints()[0]['ipAddress'])
+      try:
+        req = urllib.request.Request(url)
+        resp = urllib.request.urlopen(req)
+        version_details = json.loads(resp.read())
+        return version_details.get('currentVersion')
+      except urllib.error.HTTPError as e:
+        status_code = e.code
+        if status_code == 404:
+          return None
+        else:
+          raise e
+    return self._get_tpu_property('tensorflowVersion')
+
+  def accelerator_type(self):
+    """Return accelerator type of the TPU."""
+    return self._get_tpu_property('acceleratorType')
+
+  def api_available(self):
+    """Return if the Cloud TPU API is available, if not certain features will not work."""
+    return self._use_api
+
+  def name(self):
+    """Return the name of the tpu, or the ip address if name is not provided."""
+    return self._tpu
+
+  def get_local_ip(self):
+    """Return the local ip address of the Google Cloud VM the workload is running on."""
+    return _request_compute_metadata('instance/network-interfaces/0/ip')
+
+  def network_endpoints(self):
+    """Return a list of tpu endpoints."""
+    if not self._use_api:
+      return list(_environment_var_to_network_endpoints(self._tpu))
+    response = self._fetch_cloud_tpu_metadata()
+
+    if response.get('state') != 'READY':
+      raise RuntimeError('TPU "%s" is not yet ready; state: "%s"' %
+                         (self._tpu, response.get('state')))
+    if 'networkEndpoints' in response:
+      return response['networkEndpoints']
+    else:
+      return [{'ipAddress': response['ipAddress'], 'port': response['port']}]
+
+  def wait_for_healthy(self, timeout_s=1200, interval=30):
+    """Wait for TPU to become healthy or raise error if timeout reached.
+
+    Args:
+      timeout_s (int): The timeout in seconds for waiting TPU to become healthy.
+      interval (int): The interval in seconds to poll the TPU for health.
+
+    Raises:
+      RuntimeError: If the TPU doesn't become healthy by the timeout.
+    """
+    timeout = time.time() + timeout_s
+    while self.health() != 'HEALTHY':
+      logging.warning(
+          ('Waiting for TPU "%s" with state "%s" '
+           'and health "%s" to become healthy'),
+          self.name(), self.state(), self.health())
+      if time.time() + interval > timeout:
+        raise RuntimeError(
+            'Timed out waiting for TPU "%s" to become healthy' % self.name())
+      time.sleep(interval)
+
+    logging.warning('TPU "%s" is healthy.', self.name())
+
+  def configure_tpu_version(self, version, restart_type='always'):
+    """Configure TPU software version.
+
+    Args:
+      version (string): Version of software to configure the TPU with.
+      restart_type (string): Restart behaviour when switching versions,
+        defaults to always restart. Options are 'always', 'ifNeeded'.
+
+    """
+
+    def configure_worker(worker):
+      """Configure individual TPU worker.
+
+      Args:
+        worker: A dict with the field ipAddress where the configure request will
+          be sent.
+      """
+      ip_address = worker['ipAddress']
+      url = (_VERSION_SWITCHER_ENDPOINT + '/{}?restartType={}').format(
+          ip_address, version, restart_type)
+      req = urllib.request.Request(url, data=b'')
+      try:
+        urllib.request.urlopen(req)
+      except urllib.error.HTTPError as e:
+        status_code = e.code
+        if status_code == 404:
+          raise Exception(
+              'Tensorflow version {} is not available on Cloud TPU, '
+              'try a previous nightly version or refer to '
+              'https://cloud.google.com/tpu/docs/release-notes for '
+              'the latest official version.'.format(version))
+        else:
+          raise Exception('Failed to configure worker {}'.format(ip_address))
+
+    workers = self.network_endpoints()
+
+    with futures.ThreadPoolExecutor(max_workers=len(workers)) as executor:
+      results = executor.map(configure_worker, workers)
+      for result in results:
+        if result:
+          result.result()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/client/version.py

@@ -0,0 +1,17 @@
+# 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.
+# =============================================================================
+"""Cloud TPU Client version information."""
+
+__version__ = "0.11"

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/ops/tpu_ops.py

@@ -0,0 +1,608 @@
+# 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.
+# =============================================================================
+"""Operations for TPUs."""
+
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+# pylint: disable=wildcard-import,unused-import
+from tensorflow.python.ops import gen_tpu_ops
+from tensorflow.python.ops.gen_tpu_ops import *
+# pylint: enable=wildcard-import,unused-import
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.tpu import tpu_function
+from tensorflow.python.util.tf_export import tf_export
+
+
+ops.NotDifferentiable("TPUReplicatedInput")
+
+
+def _create_default_group_assignment():
+  num_shards = tpu_function.get_tpu_context().number_of_shards
+  if num_shards is None:
+    logging.warning(
+        "cross_replica_sum should be used within a tpu_shard_context, but "
+        "got unset number_of_shards. Assuming 1.")
+    num_shards = 1
+  group_assignment = [list(range(num_shards))]
+  return group_assignment
+
+
+def all_to_all(x,
+               concat_dimension,
+               split_dimension,
+               split_count,
+               group_assignment=None,
+               name=None):
+  """Exchange data across TPU replicas.
+
+  Args:
+    x: The local tensor.
+    concat_dimension: The dimension number to concatenate.
+    split_dimension: The dimension number to split.
+    split_count: The number of splits, this number must equal to the sub-group
+      size(group_assignment.get_shape()[1])
+    group_assignment: Optional 2d int32 lists with shape [num_groups,
+      num_replicas_per_group]. `group_assignment[i]` represents the replica ids
+      in the ith subgroup.
+    name: Optional op name.
+
+  Returns:
+    A `Tensor` which is concatenated by data from different replicas.
+  """
+  if group_assignment is None:
+    group_assignment = _create_default_group_assignment()
+  return gen_tpu_ops.all_to_all(
+      x,
+      group_assignment,
+      concat_dimension=concat_dimension,
+      split_dimension=split_dimension,
+      split_count=split_count,
+      name=name)
+
+
+@ops.RegisterGradient("AllToAll")
+def _all_to_all_grad(op, grad):
+  # The gradient of a all-to-all is also a all-to-all but the
+  # split_dimension and concat_dimension is swapped.
+  # The gradient with respect to group_assignment is None.
+  return [
+      gen_tpu_ops.all_to_all(
+          grad,
+          op.inputs[1],
+          concat_dimension=op.get_attr("split_dimension"),
+          split_dimension=op.get_attr("concat_dimension"),
+          split_count=op.get_attr("split_count")), None
+  ]
+
+
+@tf_export(v1=["tpu.cross_replica_sum"])
+def cross_replica_sum(x, group_assignment=None, name=None):
+  """Sum the input tensor across replicas according to group_assignment.
+
+  Args:
+    x: The local tensor to the sum.
+    group_assignment: Optional 2d int32 lists with shape [num_groups,
+      num_replicas_per_group]. `group_assignment[i]` represents the replica ids
+      in the ith subgroup.
+    name: Optional op name.
+
+  Returns:
+    A `Tensor` which is summed across replicas.
+  """
+  if group_assignment is None:
+    group_assignment = _create_default_group_assignment()
+
+  return gen_tpu_ops.cross_replica_sum(x, group_assignment, name=name)
+
+
+def collective_permute(x, source_target_pairs, name=None):
+  """Permute the input tensor across replicas given source_target_pairs.
+
+  For each source_target_pair <a, b>, we send replica a's input to replica b.
+  Each replica id must only appear once in the source column. Also it must
+  only appear once in the target column.
+  For the replica id not in the target column, this op returns a zero tensor
+  with the same shape and dtype of the input x.
+
+  For example, suppose there are 4 TPU instances: `[A, B, C, D]`. Passing
+  source_target_pairs=`[[0,1],[1,2],[2,3]]` gets the outputs:
+  `[0, A, B, C]`.
+
+  Args:
+    x: The local tensor to be permuted.
+    source_target_pairs: 2d int lists with shape [num_pairs, 2].
+      source_target_pairs[i][0] represents the source replica id and
+      source_target_pairs[i][1] represents the target replica id.
+    name: Optional op name.
+
+  Returns:
+    A `Tensor` which is permuted.
+  """
+  return gen_tpu_ops.collective_permute(x, source_target_pairs, name=name)
+
+
+@ops.RegisterGradient("CollectivePermute")
+def _collective_permute_grad(op, grad):
+  # The gradient of a collective permute operation is also a collective
+  # permute, but with source/target pairs reversed. The gradient with respect
+  # to input argument `source_target_pairs` is `None`.
+  source_target_pairs = op.inputs[1][:, ::-1]
+  return [gen_tpu_ops.collective_permute(grad, source_target_pairs), None]
+
+
+@ops.RegisterGradient("CrossReplicaSum")
+def _cross_replica_sum_grad(op, grad):
+  # The gradient of a cross replica sum is also a cross-replica sum.
+  # The gradient with respect to group_assignment is None.
+  return [gen_tpu_ops.cross_replica_sum(grad, op.inputs[1]), None]
+
+
+# This extra type checking exists to give a more helpful error message.
+_SUPPORTED_INFEED_DTYPES = frozenset([
+    dtypes.bool, dtypes.int32, dtypes.int64, dtypes.bfloat16, dtypes.float32,
+    dtypes.complex64, dtypes.uint32, dtypes.uint8, dtypes.int8
+])
+
+
+@ops.RegisterGradient("TPUEmbeddingActivations")
+def _embedding_activations_grad(activations_op, grad_wrt_activations):
+  """Saves the gradient of embedding activations ops in a graph collection."""
+  g = ops.get_default_graph()
+  table_id = activations_op.get_attr("table_id")
+  lookup_id = activations_op.get_attr("lookup_id")
+  table_gradients = g.get_collection_ref("tpu_embedding_gradients_table_%d" %
+                                         table_id)
+
+  if not table_gradients:
+    raise RuntimeError(
+        "Gradients for TPUEmbedding have been generated in non-training mode."
+        "This is not expected. Consider putting your Optimizer.minimize code "
+        "behind the training mode condition check. For Estimator, you can "
+        "do \n\n"
+        "    if mode == tf.estimator.ModeKeys.TRAIN:\n"
+        "        train_op = opt.minimize(loss)\n"
+        "\n")
+
+  if lookup_id < 0 or lookup_id >= len(table_gradients):
+    raise RuntimeError(
+        "Gradients (w.r.t. TPUEmbedding activations) generated for table_id {} "
+        "and lookup_id {}. The lookup_id attribute is outside the expected "
+        "range [0, {}).".format(table_id, lookup_id, len(table_gradients)))
+
+  if table_gradients[lookup_id] is not None:
+    raise RuntimeError(
+        "Duplicate gradients (w.r.t. TPUEmbedding activations) generated for "
+        "table_id {} and lookup_id {}. This happens when there are multiple "
+        "calls to tf.gradients in a graph containing TPU embeddings. "
+        "TF cannot identify which gradient to use for updating the embedding "
+        "variables. Consider placing tf.StopGradient around tensors where "
+        "variable update is not required. Previous gradients were generated by "
+        "the following callstack: {}.".format(
+            table_id, lookup_id, table_gradients[lookup_id].op.traceback))
+
+  table_gradients[lookup_id] = array_ops.identity(grad_wrt_activations)
+  return [
+      # RegisterGradient requires that value be returned for all inputs. Since
+      # the first argument (tpu_gradient_variable_{table_name}) has shape [1],
+      # we will return zeros(shape=[1]). The actual gradient w.r.t. the
+      # embedding activations (grad_wrt_activations) has the same shape as the
+      # activations returned by  embedding_activations.
+      array_ops.zeros(arg.shape, dtype=dtypes.float32)
+      for arg in activations_op.inputs
+  ]
+
+
+def infeed_dequeue(dtype, shape, name=None):
+  """A placeholder op for a value that will be fed into the computation.
+
+  Args:
+    dtype: A `tf.DType`. The type of elements in the tensor.
+    shape: A `tf.TensorShape` or list of `ints`. The shape of the tensor.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `dtype`.
+    A tensor that will be provided using the infeed mechanism.
+
+  Raises:
+    TypeError: If 'dtype` is not a supported infeed type.
+  """
+  if dtype not in _SUPPORTED_INFEED_DTYPES:
+    raise TypeError(
+        "Operation '{}' has type {} which is not a supported TPU infeed type. "
+        "Supported types are: {}".format(name, dtype,
+                                         list(_SUPPORTED_INFEED_DTYPES)))
+
+  return gen_tpu_ops.infeed_dequeue(dtype, shape, name=name)
+
+
+# pylint: disable=redefined-outer-name
+def infeed_dequeue_tuple(dtypes, shapes, name=None):
+  """A placeholder op for values fed into the TPU simultaneously as a tuple.
+
+  Args:
+    dtypes: A list of `tf.DType`s that has length `>= 1`. The element types of
+      each element in `outputs`.
+    shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`). The
+      shapes of each tensor in `outputs`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A list of `Tensor` objects of type `dtypes`.
+    A list of tensors that will be provided using the infeed mechanism.
+
+  Raises:
+    TypeError: If a type in 'dtypes` is not a supported infeed type.
+  """
+  for dtype in dtypes:
+    if dtype not in _SUPPORTED_INFEED_DTYPES:
+      raise TypeError(
+          "{} is not a supported TPU infeed type. Supported types are: "
+          "{}".format(dtype, list(_SUPPORTED_INFEED_DTYPES)))
+  return gen_tpu_ops.infeed_dequeue_tuple(dtypes, shapes, name=name)
+
+
+# pylint: enable=redefined-outer-name
+
+
+# pylint: disable=protected-access
+def send_tpu_embedding_gradients(inputs,
+                                 config,
+                                 learning_rates=None,
+                                 name=None):
+  """A placeholder op for feeding per-sample gradients to the embedding layer.
+
+  Args:
+    inputs: A TensorList of gradients with which to update embedding tables.
+      This argument has the same length and shapes as the return value of
+      RecvTPUEmbeddingActivations, but contains gradients of the model's loss
+      with respect to the embedding activations. The embedding tables are
+      updated from these gradients via the optimizers specified in the TPU
+      embedding configuration given to tpu.initialize_system.
+    config: Serialized TPUEmbeddingConfiguration proto.
+    learning_rates: A TensorList of float32 scalars, one for each dynamic
+        learning rate tag: see the comments in
+          //third_party/tensorflow/core/protobuf/tpu/
+          optimization_parameters.proto. Multiple tables can share the same
+          dynamic learning rate tag as specified in the configuration. If the
+          learning rates for all tables are constant, this list should be empty.
+    name: A name for the operation (optional).
+
+  Returns:
+    A SendTPUEmbeddingGradients operation.
+  """
+  if learning_rates is None:
+    learning_rates = []
+  return gen_tpu_ops.send_tpu_embedding_gradients(
+      inputs=inputs, learning_rates=learning_rates, config=config, name=name)
+
+
+send_tpu_embedding_gradients.__doc__ = (
+    gen_tpu_ops.send_tpu_embedding_gradients.__doc__)
+
+
+# pylint: disable=protected-access
+def enqueue_tpu_embedding_integer_batch(batch,
+                                        device_ordinal,
+                                        mode_override=None,
+                                        name=None):
+  """A placeholder op for enqueueing embedding IDs to the TPU.
+
+  Args:
+    batch: A list of 1D tensors, one for each embedding table, containing the
+      indices into the tables.
+    device_ordinal: The TPU device to use. Should be >= 0 and less than the
+      number of TPU cores in the task on which the node is placed.
+    mode_override: A string input that overrides the mode specified in the
+      TPUEmbeddingConfiguration. Supported values are {'unspecified',
+      'inference', 'train', 'backward_pass_only'}. When set to 'unspecified',
+      the mode set in TPUEmbeddingConfiguration is used, otherwise mode_override
+      is used (optional).
+    name: A name for the operation (optional).
+
+  Returns:
+    An EnqueueTPUEmbeddingIntegerBatch operation.
+  """
+  if mode_override is None:
+    mode_override = "unspecified"
+  return gen_tpu_ops.enqueue_tpu_embedding_integer_batch(
+      batch=batch,
+      device_ordinal=device_ordinal,
+      mode_override=mode_override,
+      name=name)
+
+
+enqueue_tpu_embedding_integer_batch.__doc__ = (
+    gen_tpu_ops.enqueue_tpu_embedding_integer_batch.__doc__)
+
+
+# pylint: disable=protected-access
+def enqueue_tpu_embedding_sparse_batch(sample_indices,
+                                       embedding_indices,
+                                       aggregation_weights,
+                                       device_ordinal,
+                                       combiners=None,
+                                       mode_override=None,
+                                       name=None):
+  """A placeholder op for enqueueing embedding IDs to the TPU.
+
+  Args:
+    sample_indices: A list of rank 1 Tensors specifying the training example and
+      feature to which the corresponding embedding_indices and
+      aggregation_weights values belong. sample_indices[i] must equal b * nf +
+      f, where nf is the number of features from the corresponding table, f is
+      in [0, nf), and b is in [0, batch size). Both int32 and int64 are allowed,
+      and will be converted to int32 internally.
+    embedding_indices: A list of rank 1 Tensors, indices into the embedding
+      tables. Both int32 and int64 are allowed and will be converted to int32
+      internally.
+    aggregation_weights: A list of rank 1 Tensors containing per sample -- i.e.,
+      per (training example, feature) -- aggregation weights. Both float32 and
+      float64 are allowed and will be converted to float32 internally.
+    device_ordinal: The TPU device to use. Should be >= 0 and less than the
+      number of TPU cores in the task on which the node is placed.
+    combiners: A list of string scalars, one for each embedding table that
+      specify how to normalize the embedding activations after weighted
+      summation. Supported combiners are 'mean', 'sum', or 'sqrtn'. It is
+      invalid to have the sum of the weights be 0 for 'mean' or the sum of the
+      squared weights be 0 for 'sqrtn'. If combiners isn't passed, the default
+      is to use 'sum' for all tables (optional).
+    mode_override: A string input that overrides the mode specified in the
+      TPUEmbeddingConfiguration. Supported values are {'unspecified',
+      'inference', 'train', 'backward_pass_only'}. When set to 'unspecified',
+      the mode set in TPUEmbeddingConfiguration is used, otherwise mode_override
+      is used (optional).
+    name: A name for the operation (optional).
+
+  Returns:
+    An EnqueueTPUEmbeddingSparseBatch operation.
+  """
+  if mode_override is None:
+    mode_override = "unspecified"
+  return gen_tpu_ops.enqueue_tpu_embedding_sparse_batch(
+      sample_indices=sample_indices,
+      embedding_indices=embedding_indices,
+      aggregation_weights=aggregation_weights,
+      device_ordinal=device_ordinal,
+      combiners=combiners,
+      mode_override=mode_override,
+      name=name)
+
+
+enqueue_tpu_embedding_sparse_batch.__doc__ = (
+    gen_tpu_ops.enqueue_tpu_embedding_sparse_batch.__doc__)
+
+
+# pylint: disable=protected-access
+def enqueue_tpu_embedding_sparse_tensor_batch(sample_indices,
+                                              embedding_indices,
+                                              aggregation_weights,
+                                              table_ids,
+                                              device_ordinal,
+                                              max_sequence_lengths=None,
+                                              num_features=None,
+                                              combiners=None,
+                                              mode_override=None,
+                                              name=None):
+  """A placeholder op for enqueueing embedding IDs to the TPU.
+
+  Args:
+    sample_indices: A list of rank 2 Tensors specifying the training example to
+      which the corresponding embedding_indices and aggregation_weights values
+      belong. It corresponds to sp_ids.indices in embedding_lookup_sparse(). If
+      the size of its first dimension is 0, we assume each embedding_indices
+      belongs to a different sample. Both int32 and int64 are allowed and will
+      be converted to int32 internally.
+    embedding_indices: A list of rank 1 Tensors, indices into the embedding
+      tables. It corresponds to sp_ids.values in embedding_lookup_sparse(). Both
+      int32 and int64 are allowed and will be converted to int32 internally.
+    aggregation_weights: A list of rank 1 Tensors containing per training
+      example aggregation weights. It corresponds to sp_weights.values in
+      embedding_lookup_sparse(). If the size of its first dimension is 0, we
+      assume all weights are 1. Both float32 and float64 are allowed and will be
+      converted to float32 internally.
+    table_ids: A list of integers specifying the identifier of the embedding
+      table (offset of TableDescriptor in the TPUEmbeddingConfiguration) to
+      lookup the corresponding input. The ith input is looked up using
+      table_ids[i]. The size of the table_ids list must be equal to that of
+      sample_indices, embedding_indices and aggregation_weights.
+    device_ordinal: The TPU device to use. Should be >= 0 and less than the
+      number of TPU cores in the task on which the node is placed.
+    max_sequence_lengths: A list of integers, the size of which is equal to
+      sample_indices. If equal to 0, the corresponding feature is considered to
+      be a non-sequence feature, If greater than 0, the corresponding feature is
+      a sequence feature with the given maximal length. If None, then we assume
+      a list of all zeroes.
+    num_features: A list of integers, the size of which is equal to
+      sample_indices. If non-empty, entries in this list must be at least 1. For
+      each batch element, we will take num_features rows of the input tensor for
+      embedding lookup. E.g., when sample_indices is empty, the embedding
+      indices must be of shape (batch_size*num_features).
+    combiners: A list of string scalars, one for each embedding table that
+      specify how to normalize the embedding activations after weighted
+      summation. Supported combiners are 'mean', 'sum', or 'sqrtn'. It is
+      invalid to have the sum of the weights be 0 for 'mean' or the sum of the
+      squared weights be 0 for 'sqrtn'. If combiners isn't passed, the default
+      is to use 'sum' for all tables (optional).
+    mode_override: A string input that overrides the mode specified in the
+      TPUEmbeddingConfiguration. Supported values are {'unspecified',
+      'inference', 'train', 'backward_pass_only'}. When set to 'unspecified',
+      the mode set in TPUEmbeddingConfiguration is used, otherwise mode_override
+      is used (optional).
+    name: A name for the operation (optional).
+
+  Returns:
+    An EnqueueTPUEmbeddingSparseTensorBatch operation.
+  """
+  if mode_override is None:
+    mode_override = "unspecified"
+  return gen_tpu_ops.enqueue_tpu_embedding_sparse_tensor_batch(
+      sample_indices=sample_indices,
+      embedding_indices=embedding_indices,
+      aggregation_weights=aggregation_weights,
+      table_ids=table_ids,
+      device_ordinal=device_ordinal,
+      max_sequence_lengths=max_sequence_lengths,
+      combiners=combiners,
+      mode_override=mode_override,
+      num_features=num_features,
+      name=name)
+
+
+enqueue_tpu_embedding_sparse_tensor_batch.__doc__ = (
+    gen_tpu_ops.enqueue_tpu_embedding_sparse_tensor_batch.__doc__)
+
+
+# pylint: disable=protected-access
+def enqueue_tpu_embedding_ragged_tensor_batch(sample_splits,
+                                              embedding_indices,
+                                              aggregation_weights,
+                                              table_ids,
+                                              device_ordinal,
+                                              max_sequence_lengths=None,
+                                              num_features=None,
+                                              combiners=None,
+                                              mode_override=None,
+                                              name=None):
+  """A placeholder op for enqueueing embedding IDs to the TPU.
+
+  Args:
+    sample_splits: A list of rank 1 Tensors specifying the break points for
+      splitting embedding_indices and aggregation_weights into rows. It
+      corresponds to ids.row_splits in embedding_lookup(), when ids is a
+      RaggedTensor. Both int32 and int64 are allowed and will be converted to
+      int32 internally.
+    embedding_indices: A list of rank 1 Tensors, indices into the embedding
+      tables. It corresponds to ids.values in embedding_lookup(), when ids is a
+      RaggedTensor. Both int32 and int64 are allowed and will be converted to
+      int32 internally.
+    aggregation_weights: A list of rank 1 Tensors containing per training
+      example aggregation weights. It corresponds to the values field of a
+      RaggedTensor with the same row_splits as ids in embedding_lookup(), when
+      ids is a RaggedTensor. Both float32 and float64 are allowed and will be
+      converted to float32 internally.
+    table_ids: A list of integers specifying the identifier of the embedding
+      table (offset of TableDescriptor in the TPUEmbeddingConfiguration) to
+      lookup the corresponding input. The ith input is looked up using
+      table_ids[i]. The size of the table_ids list must be equal to that of
+      sample_indices, embedding_indices and aggregation_weights.
+    device_ordinal: The TPU device to use. Should be >= 0 and less than the
+      number of TPU cores in the task on which the node is placed.
+    max_sequence_lengths: A list of integers, the size of which is equal to
+      sample_indices. If equal to 0, the corresponding feature is considered to
+      be a non-sequence feature, If greater than 0, the corresponding feature is
+      a sequence feature with the given maximal length. If None, then we assume
+      a list of all zeroes.
+    num_features: A list of integers, the size of which must be equal to
+      sample_indices. If non-empty, entries in this list must be at least 1. For
+      each batch element, we will take num_features rows of the input tensor for
+      embedding lookup. E.g., when sample_indices is empty, the embedding
+      indices must be of shape (batch_size*num_features).
+    combiners: A list of string scalars, one for each embedding table that
+      specify how to normalize the embedding activations after weighted
+      summation. Supported combiners are 'mean', 'sum', or 'sqrtn'. It is
+      invalid to have the sum of the weights be 0 for 'mean' or the sum of the
+      squared weights be 0 for 'sqrtn'. If combiners isn't passed, the default
+      is to use 'sum' for all tables (optional).
+    mode_override: A string input that overrides the mode specified in the
+      TPUEmbeddingConfiguration. Supported values are {'unspecified',
+      'inference', 'training', 'backward_pass_only'}. When set to 'unspecified',
+      the mode set in TPUEmbeddingConfiguration is used, otherwise mode_override
+      is used (optional).
+    name: A name for the operation (optional).
+
+  Returns:
+    An EnqueueTPUEmbeddingRaggedTensorBatch operation.
+  """
+  if mode_override is None:
+    mode_override = "unspecified"
+  return gen_tpu_ops.enqueue_tpu_embedding_ragged_tensor_batch(
+      sample_splits=sample_splits,
+      embedding_indices=embedding_indices,
+      aggregation_weights=aggregation_weights,
+      table_ids=table_ids,
+      device_ordinal=device_ordinal,
+      max_sequence_lengths=max_sequence_lengths,
+      combiners=combiners,
+      mode_override=mode_override,
+      num_features=num_features,
+      name=name)
+
+
+enqueue_tpu_embedding_ragged_tensor_batch.__doc__ = (
+    gen_tpu_ops.enqueue_tpu_embedding_ragged_tensor_batch.__doc__)
+
+
+def enqueue_tpu_embedding_arbitrary_tensor_batch(sample_indices_or_row_splits,
+                                                 embedding_indices,
+                                                 aggregation_weights,
+                                                 device_ordinal,
+                                                 combiners=None,
+                                                 mode_override=None,
+                                                 name=None):
+  """A placeholder op for enqueueing embedding IDs to the TPU.
+
+  Args:
+    sample_indices_or_row_splits: A list of rank 1 or 2 Tensors. When rank 2,
+      the tensors specify the training example to which the corresponding
+      embedding_indices and aggregation_weights values belong. If the size of
+      its first dimension is 0, we assume each embedding_indices belongs to a
+      different sample. Both int32 and int64 are allowed and will be converted
+      to int32 internally. When rank 1, the tensors specify the row splits for
+      splitting embedding_indices and aggregation_weights into rows. It
+      corresponds to ids.row_splits in embedding_lookup(), when ids is a
+      RaggedTensor. When enqueuing N-D ragged tensor, only the last dimension is
+      allowed to be ragged. the row splits is 1-D dense tensor. When empty, we
+      assume a dense tensor is passed to the op. Both int32 and int64 are
+      allowed and will be converted to int32 internally.
+    embedding_indices: A list of rank 1 Tensors, indices into the embedding
+      tables. Both int32 and int64 are allowed and will be converted to int32
+      internally.
+    aggregation_weights: A list of rank 1 Tensors containing per training
+      example aggregation weights. Both float32 and float64 are allowed and will
+      be converted to float32 internally.
+    device_ordinal: The TPU device to use. Should be >= 0 and less than the
+      number of TPU cores in the task on which the node is placed.
+    combiners: A list of string scalars, one for each embedding table that
+      specify how to normalize the embedding activations after weighted
+      summation. Supported combiners are 'mean', 'sum', or 'sqrtn'. It is
+      invalid to have the sum of the weights be 0 for 'mean' or the sum of the
+      squared weights be 0 for 'sqrtn'. If combiners isn't passed, the default
+      is to use 'sum' for all tables (optional).
+    mode_override: A string input that overrides the mode specified in the
+      TPUEmbeddingConfiguration. Supported values are {'unspecified',
+      'inference', 'training', 'backward_pass_only'}. When set to 'unspecified',
+      the mode set in TPUEmbeddingConfiguration is used, otherwise mode_override
+      is used (optional).
+    name: A name for the operation (optional).
+
+  Returns:
+    An EnqueueTPUEmbeddingArbitraryTensorBatch operation.
+  """
+  if mode_override is None:
+    mode_override = "unspecified"
+  return gen_tpu_ops.enqueue_tpu_embedding_arbitrary_tensor_batch(
+      sample_indices_or_row_splits=sample_indices_or_row_splits,
+      embedding_indices=embedding_indices,
+      aggregation_weights=aggregation_weights,
+      device_ordinal=device_ordinal,
+      combiners=combiners,
+      mode_override=mode_override,
+      name=name)
+
+
+enqueue_tpu_embedding_arbitrary_tensor_batch.__doc__ = (
+    gen_tpu_ops.enqueue_tpu_embedding_arbitrary_tensor_batch.__doc__)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/tpu_optimizer.py

@@ -0,0 +1,225 @@
+# 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.
+# =============================================================================
+
+"""Optimizer that implements cross-shard gradient reduction for TPU."""
+
+
+from tensorflow.python.framework import ops
+from tensorflow.python.ops.losses import losses
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.tpu import tpu_function
+from tensorflow.python.tpu.ops import tpu_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["tpu.CrossShardOptimizer"])
+class CrossShardOptimizer(optimizer.Optimizer):
+  """An optimizer that averages gradients across TPU shards."""
+
+  def __init__(self,
+               opt,
+               reduction=losses.Reduction.MEAN,
+               name="CrossShardOptimizer",
+               group_assignment=None):
+    """Construct a new cross-shard optimizer.
+
+    Args:
+      opt: An existing `Optimizer` to encapsulate.
+      reduction: The reduction to apply to the shard losses.
+      name: Optional name prefix for the operations created when applying
+        gradients. Defaults to "CrossShardOptimizer".
+      group_assignment: Optional 2d int32 lists with shape
+        [num_groups, num_replicas_per_group] which describles how to apply
+        optimizer to subgroups.
+
+    Raises:
+      ValueError: If reduction is not a valid cross-shard reduction.
+    """
+    accepted_reductions = (losses.Reduction.SUM, losses.Reduction.MEAN)
+    if reduction not in accepted_reductions:
+      raise ValueError(
+          f"Argument `reduction` should be one of {accepted_reductions}. "
+          f"Received: {reduction}")
+    if not isinstance(opt, optimizer.Optimizer):
+      raise TypeError(
+          "CrossShardOptimizer only works with tf.training.Optimizer and not "
+          f"Keras Optimizer. Received: {opt}. "
+          "If you are using TPUStrategy, "
+          "Keras Optimizer will sum gradients across replicas."
+          "If you are using TPUEstimator, you may instead sum your gradients "
+          "with:\n"
+          "`grads = [tf.compat.v1.tpu.cross_replica_sum(g) for g in grads]`\n"
+          "If you want to average your gradients, rescale your loss with: "
+          "`loss /= global_batch_size`")
+
+    super(CrossShardOptimizer, self).__init__(False, name)
+    self._opt = opt
+    self._reduction = reduction
+    self._group_assignment = group_assignment
+
+  def _verify_and_get_subgroup_size(self, group_assignment, num_shards):
+    """Verify group_assignment and get the subgroup size".
+
+    Args:
+      group_assignment: list of group ids for applying the optimizer
+        to subgroups.
+      num_shards: The number of TPU shards.
+
+    Returns:
+      The size of one subgroup in group_assignment.
+
+    Raises:
+      ValueError: If group_assignment is invalid.
+    """
+    if not group_assignment:
+      return None
+    if not (isinstance(group_assignment, list) and
+            all(isinstance(i, list) for i in group_assignment)):
+      raise ValueError(
+          f"Argument `group_assignment` must be a list of lists. "
+          f"Received: {group_assignment}")
+
+    replica_ids = set()
+    for g in group_assignment:
+      for i in g:
+        replica_ids.add(i)
+
+    if set(range(num_shards)) != replica_ids:
+      raise ValueError(
+          f"Argument `group_assignment` must be a permutation of "
+          f"range({num_shards}). Received: {group_assignment}")
+
+    subgroup_size_list = [len(group) for group in group_assignment]
+    if all(subgroup_size_list[0] == size for size in subgroup_size_list):
+      return subgroup_size_list[0]
+    else:
+      raise ValueError("The size of each subgroup in `group_assignment` must "
+                       f"be equal. Received: {group_assignment}")
+
+  def compute_gradients(self, loss, var_list=None, **kwargs):
+    """Compute gradients of "loss" for the variables in "var_list".
+
+    This simply wraps `compute_gradients()` from the real optimizer. The
+    gradients will be aggregated in `apply_gradients()` so that user can
+    modify the gradients like clipping with per replica global norm if needed.
+    The global norm with aggregated gradients can be bad as one replica's huge
+    gradients can hurt the gradients from other replicas.
+
+    When the CrossShardOptimizer is constructed with
+    `reduction == losses.Reduction.MEAN` (default), this function scales the
+    loss by `1.0 / num_shards` before computing the gradients. Assuming the
+    optimizer uses the default implementation of `compute_gradients()`, the
+    gradients of the scaled loss are scaled by `1.0 / num_shards` compared to
+    the gradients of the original loss. This scaling factor is important because
+    `apply_gradients()` sums gradients across shards, rather than averaging
+    them. However, the scaling factor must be taken into account when clipping
+    the norm of the gradients or performing other postprocessing.
+
+    Args:
+      loss: A Tensor containing the value to minimize.
+      var_list: Optional list or tuple of `tf.Variable` to update to minimize
+        `loss`.  Defaults to the list of variables collected in the graph
+        under the key `GraphKey.TRAINABLE_VARIABLES`.
+      **kwargs: Keyword arguments for compute_gradients().
+
+    Returns:
+      A list of (gradient, variable) pairs.
+
+    Raises:
+      ValueError: If not within a tpu_shard_context or group_assignment is
+        invalid.
+    """
+    num_shards = tpu_function.get_tpu_context().number_of_shards
+    if num_shards is None:
+      logging.warning(
+          "CrossShardOptimizer should be used within a tpu_shard_context, but "
+          "got unset number_of_shards. Assuming 1.")
+      num_shards = 1
+
+    subgroup_size = self._verify_and_get_subgroup_size(self._group_assignment,
+                                                       num_shards)
+
+    if num_shards > 1 and self._reduction == losses.Reduction.MEAN:
+      if self._group_assignment:
+        scale = 1.0 / subgroup_size
+      else:
+        scale = 1.0 / num_shards
+      loss *= scale
+
+    return self._opt.compute_gradients(loss, var_list=var_list, **kwargs)
+
+  def apply_gradients(self, grads_and_vars, global_step=None, name=None):
+    """Apply gradients to variables.
+
+    Calls tpu_ops.cross_replica_sum() to sum gradient contributions across
+    replicas, and then applies the real optimizer.
+
+    Args:
+      grads_and_vars: List of (gradient, variable) pairs as returned by
+        compute_gradients().
+      global_step: Optional Variable to increment by one after the
+        variables have been updated.
+      name: Optional name for the returned operation.  Default to the
+        name passed to the Optimizer constructor.
+
+    Returns:
+      An `Operation` that applies the gradients. If `global_step` was not None,
+      that operation also increments `global_step`.
+
+    Raises:
+      ValueError: If the grads_and_vars is malformed.
+    """
+    summed_grads_and_vars = []
+    for (grad, var) in grads_and_vars:
+      if grad is None:
+        summed_grads_and_vars.append((grad, var))
+      else:
+        with ops.colocate_with(grad):
+          summed_grads_and_vars.append((tpu_ops.cross_replica_sum(
+              grad, self._group_assignment), var))
+    return self._opt.apply_gradients(summed_grads_and_vars, global_step, name)
+
+  def get_slot(self, *args, **kwargs):
+    """Return a slot named "name" created for "var" by the Optimizer.
+
+    This simply wraps the get_slot() from the actual optimizer.
+
+    Args:
+      *args: Arguments for get_slot().
+      **kwargs: Keyword arguments for get_slot().
+
+    Returns:
+      The `Variable` for the slot if it was created, `None` otherwise.
+    """
+    return self._opt.get_slot(*args, **kwargs)
+
+  def get_slot_names(self, *args, **kwargs):
+    """Return a list of the names of slots created by the `Optimizer`.
+
+    This simply wraps the get_slot_names() from the actual optimizer.
+
+    Args:
+      *args: Arguments for get_slot().
+      **kwargs: Keyword arguments for get_slot().
+
+    Returns:
+      A list of strings.
+    """
+    return self._opt.get_slot_names(*args, **kwargs)
+
+  def variables(self):
+    """Forwarding the variables from the underlying optimizer."""
+    return self._opt.variables()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/tpu_replication.py

@@ -0,0 +1,772 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file8 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.
+# ======================================
+
+"""OutsideCompilation, TPUReplicateContext, and supporting functions."""
+
+from typing import Any, Callable, List, Optional, Text, Tuple, Union
+from absl import logging
+from tensorflow.core.framework import attr_value_pb2
+from tensorflow.python.distribute import device_util
+from tensorflow.python.distribute import distribute_lib
+from tensorflow.python.framework import device as pydev
+from tensorflow.python.framework import errors
+from tensorflow.python.framework import func_graph
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import variables
+from tensorflow.python.tpu import device_assignment as device_assignment_lib
+from tensorflow.python.tpu.ops import tpu_ops
+from tensorflow.python.types import core as core_types
+from tensorflow.python.util import compat
+from tensorflow.python.util.tf_export import tf_export
+
+_MAX_WARNING_LINES = 5
+_TPU_REPLICATE_ATTR = "_tpu_replicate"
+_OUTSIDE_COMPILATION_ATTR = "_xla_outside_compilation"
+_MAP_OUTSIDE_COMPILATION_ATTR = "_xla_map_outside_compilation"
+
+# Operations that indicate some error in the users graph, e.g. a placeholder
+# that's introduced outside of the infeed.
+_DENYLISTED_OPS = frozenset([
+    "Placeholder",
+])
+
+
+# XLA doesn't currently support reading of intermediate tensors, thus some ops
+# are not supported.
+_UNSUPPORTED_OPS = frozenset([
+    "AudioSummary",
+    "AudioSummaryV2",
+    "HistogramSummary",
+    "ImageSummary",
+    "MergeSummary",
+    "Print",
+    "ScalarSummary",
+    "TensorSummary",
+    "TensorSummaryV2",
+])
+
+
+def is_tpu_strategy(strategy: Any) -> bool:
+  is_tpu_strat = lambda k: k.__name__.startswith("TPUStrategy")
+  clz = strategy.__class__
+  return is_tpu_strat(clz) or any(map(is_tpu_strat, clz.__bases__))
+
+
+def _enclosing_tpu_device_assignment(
+) -> Optional[device_assignment_lib.DeviceAssignment]:
+  if not distribute_lib.has_strategy():
+    return None
+  strategy = distribute_lib.get_strategy()
+  if not is_tpu_strategy(strategy):
+    return None
+  return strategy.extended._device_assignment  # pylint: disable=protected-access
+
+
+class TPUReplicateContext(control_flow_ops.XLAControlFlowContext):
+  """A `ControlFlowContext` for nodes inside a TPU computation.
+
+  The primary role of `TPUReplicateContext` is to mark operators inside a
+  tpu.replicate() computation with the attribute "_tpu_replicate=XYZ", where XYZ
+  is a unique name.
+
+  We use a `ControlFlowContext` to perform the annotation since it integrates
+  with Tensorflow constructs like ResourceVariables. For example, if a
+  `ResourceVariable` is constructed inside a tpu.replicate() block, the
+  `ResourceVariable` implementation can use
+  `with ops.control_dependencies(None)` to build the variable's definition
+  outside the replicated computation.
+  """
+
+  def __init__(self, name: Text, num_replicas: int, pivot: ops.Operation):
+    """Builds a new TPUReplicateContext.
+
+    Args:
+      name: a unique name for the context, used to populate the `_tpu_replicate`
+        attribute.
+      num_replicas: an integer that gives the number of replicas for the
+        computation.
+      pivot: a pivot node. Nodes in the TPUReplicateContext that do not have any
+        inputs will have a control dependency on the pivot node. This ensures
+        that nodes are correctly included in any enclosing control flow
+        contexts.
+    """
+    super(TPUReplicateContext, self).__init__()
+    self._num_replicas = num_replicas
+    self._outer_device_function_stack = None
+    self._oc_dev_fn_stack = None
+    self._outside_compilation_cluster = None
+    self._is_map_outside_compilation = False
+    self._outside_compilation_v2_context = None
+    self._outside_compilation_counter = 0
+    self._in_gradient_colocation = None
+    self._gradient_colocation_stack = []
+    self._host_compute_core = []
+    self._name = name
+    self._tpu_replicate_attr = attr_value_pb2.AttrValue(
+        s=compat.as_bytes(self._name)
+    )
+    self._unsupported_ops = []
+    self._pivot = pivot
+    self._replicated_vars = {}
+
+  def get_replicated_var_handle(self,
+                                name: Text,
+                                handle_id: Text,
+                                vars_: Union[List[core_types.Tensor],
+                                             List[variables.Variable]],
+                                is_mirrored: bool = False,
+                                is_packed: bool = False) -> core_types.Tensor:
+    """Returns a variable handle for replicated TPU variable 'var'.
+
+    This is a method used by an experimental replicated variable implementation
+    and is not intended as a public API.
+
+    Args:
+      name: The common name of the variable.
+      handle_id: Unique ID of the variable handle, used as the cache key.
+      vars_: The replicated TPU variables or handles.
+      is_mirrored: Whether the variables are mirrored, which guarantees the
+        values in each replica are always the same.
+      is_packed: Whether the replicated variables are packed into one variable.
+
+    Returns:
+      The handle of the TPU replicated input node.
+    """
+    device_assignment = _enclosing_tpu_device_assignment()
+    # We don't need to put device assignment as part of the replicated_vars key
+    # because each TPUReplicateContext will only have one device assignment.
+    handle = self._replicated_vars.get(handle_id)
+    if handle is not None:
+      return handle
+
+    if device_assignment is not None and not is_packed:
+      # Find a variable copy for each replica in the device assignment.
+      # Note that the order of devices for replicas for the variable and the
+      # device assignment might not match.
+      job_name = pydev.DeviceSpec.from_string(vars_[0].device).job
+      devices_to_vars = {device_util.canonicalize(v.device): v for v in vars_}
+      replicated_vars = []
+      for replica_id in range(device_assignment.num_replicas):
+        for logical_core in range(device_assignment.num_cores_per_replica):
+          device = device_util.canonicalize(
+              device_assignment.tpu_device(
+                  replica=replica_id, logical_core=logical_core, job=job_name))
+          if device in devices_to_vars:
+            replicated_vars.append(devices_to_vars[device])
+            break
+        else:
+          raise ValueError(
+              "Failed to find a variable on any device in replica {} for "
+              "current device assignment".format(replica_id)
+          )
+    else:
+      replicated_vars = vars_
+
+    # Builds a TPUReplicatedInput node for the variable, if one does not already
+    # exist. The TPUReplicatedInput node must belong to the enclosing
+    # control-flow scope of the TPUReplicateContext.
+    # TODO(phawkins): consider changing the contract of the TPU encapsulation
+    # so the TPUReplicatedInput nodes go inside the TPUReplicateContext scope
+    # instead.
+
+    _, graph = _enclosing_tpu_context_and_graph()
+    with graph.as_default():
+      # If replicated_vars are variables, get the handles. Note that this can be
+      # done inside TPUReplicateContext because replicated_vars.handle may
+      # create new ops.
+      if isinstance(replicated_vars[0], variables.Variable):
+        replicated_vars = [v.handle for v in replicated_vars]
+      # pylint: disable=protected-access
+      saved_context = graph._get_control_flow_context()
+      graph._set_control_flow_context(self.outer_context)
+      handle = tpu_ops.tpu_replicated_input(
+          replicated_vars,
+          name=name + "/handle",
+          is_mirrored_variable=is_mirrored,
+          is_packed=is_packed)
+      graph._set_control_flow_context(saved_context)
+      # pylint: enable=protected-access
+    self._replicated_vars[handle_id] = handle
+    return handle
+
+  def report_unsupported_operations(self) -> None:
+    if self._unsupported_ops:
+      op_str = "\n".join(
+          "  %s (%s)" % (op.type, op.name) for op in
+          self._unsupported_ops[:_MAX_WARNING_LINES])
+      logging.warning("%d unsupported operations found: \n%s",
+                      len(self._unsupported_ops), op_str)
+      if len(self._unsupported_ops
+            ) > _MAX_WARNING_LINES:
+        logging.warning("... and %d more",
+                        (len(self._unsupported_ops) - _MAX_WARNING_LINES))
+
+  def EnterGradientColocation(self, op: ops.Operation, gradient_uid: Text):
+    if op is not None:
+      if ops.get_default_graph()._control_flow_context is None:  # pylint: disable=protected-access
+        # If we are in TF 2 functions (control flow V2 functions, or
+        # tf.function()), we need to attach _xla_outside_compilation attribute
+        # directly because we are not in TPUReplicateContext.
+        try:
+          outside_attr = op.get_attr(_OUTSIDE_COMPILATION_ATTR).decode("ascii")
+        except ValueError:
+          # The attr was not present: do nothing.
+          return
+        parts = outside_attr.split(".")
+        cluster = parts[0] + "." + gradient_uid
+        self._outside_compilation_v2_context = OutsideCompilationV2Context(
+            cluster)
+        self._outside_compilation_v2_context.Enter()
+        return
+      self._gradient_colocation_stack.append(op)
+      if not self._outside_compilation_cluster:
+        try:
+          outside_attr = op.get_attr(_OUTSIDE_COMPILATION_ATTR).decode("ascii")
+          if self._in_gradient_colocation:
+            raise NotImplementedError(
+                "Cannot nest gradient colocation operations outside compilation"
+            )
+          if gradient_uid == "__unsupported__":
+            raise NotImplementedError(
+                "No gradient_uid calling gradient within outside_compilation")
+          # When we take the gradient of an op X in an outside_compilation
+          # cluster C in a forward computation we would like to put the ops
+          # corresponding to the gradient of X into a new outside_compilation
+          # cluster C'. However, if we take the gradient of X twice, the second
+          # one should get yet another new outside_compilation cluster C''.
+          #
+          # The mechanism we adopt is to use a 'root_cluster' which is the
+          # cluster that X was in before we took gradients, and a 'gradient_uid'
+          # which is different for every invocation of gradients, and put the
+          # gradient of X in cluster 'root_cluster.gradient_uid'.
+          #
+          # When taking a gradient of a gradient, some ops will be colocated
+          # with Op in the forward pass (e.g., cluster root_cluster) and some in
+          # the backward pass (e.g., cluster root_cluster.initial_gradient_uid).
+          # We need all of the grad-of-grad ops to be in the same cluster to
+          # avoid cyclic dependencies between clusters. We adopt a heuristic
+          # that puts any op clustered with root_cluster.<xxx> in
+          # root_cluster.gradient_uid, even if xxx was initial_gradient_uid.
+          self._in_gradient_colocation = op
+          parts = outside_attr.split(".")
+          cluster = parts[0] + "." + gradient_uid
+          self._EnterOutsideCompilationScope(cluster=cluster)
+        except ValueError:
+          # The attr was not present: do nothing.
+          pass
+
+  def ExitGradientColocation(self, op: ops.Operation, gradient_uid: Text):
+    if op is not None:
+      if ops.get_default_graph()._control_flow_context is None:  # pylint: disable=protected-access
+        # Inside a TF2 tf.function or control flow graph and `op` was not
+        # marked to be outside compiled.
+        assert self._outside_compilation_v2_context is None
+        return
+      if self._outside_compilation_v2_context is not None:
+        # Inside a TF2 tf.function or control flow graph and `op` was
+        # marked to be outside compiled.
+        self._outside_compilation_v2_context.Exit()
+        self._outside_compilation_v2_context = None
+        return
+      if not self._gradient_colocation_stack:
+        raise errors.InternalError(
+            op.node_def, op,
+            ("Badly nested gradient colocation: "
+             + f"empty stack when popping Op {op.name}")
+        )
+      last_op = self._gradient_colocation_stack.pop()
+      if op is last_op:
+        if op is self._in_gradient_colocation:
+          self._in_gradient_colocation = None
+          self._ExitOutsideCompilationScope()
+      else:
+        raise errors.InternalError(
+            op.node_def, op,
+            ("Badly nested gradient colocation, " +
+             f"expected {last_op}, got {op.name}")
+        )
+
+  def _EnterOutsideCompilationScope(
+      self, cluster: Optional[Text] = None, is_map_outside_compilation=False
+  ):
+    class FakeOp(object):
+      """A helper class to determine the current device.
+
+      Supports only the type and device set/get methods needed to run the
+      graph's _apply_device_function method.
+      """
+
+      def __init__(self):
+        self._device = ""
+
+      @property
+      def type(self):
+        return "FakeOp"
+
+      @property
+      def device(self):
+        return self._device
+
+      def _set_device(self, device):
+        if isinstance(device, pydev.DeviceSpec):
+          self._device = device.to_string()
+        else:
+          self._device = device
+
+      def _set_device_from_string(self, device_str):
+        self._device = device_str
+
+    if self._outside_compilation_cluster:
+      raise NotImplementedError("Cannot nest outside_compilation clusters")
+    if cluster:
+      self._outside_compilation_cluster = cluster
+    else:
+      self._outside_compilation_cluster = str(self._outside_compilation_counter)
+      self._outside_compilation_counter += 1
+    if is_map_outside_compilation:
+      self._is_map_outside_compilation = True
+    graph = ops.get_default_graph()
+    fake_op = FakeOp()
+    graph._apply_device_functions(fake_op)  # pylint: disable=protected-access
+    device = pydev.DeviceSpec.from_string(fake_op.device)
+    if (device.device_type == "TPU_REPLICATED_CORE" and
+        device.device_index is not None):
+      self._host_compute_core.append(self._outside_compilation_cluster + ":" +
+                                     str(device.device_index))
+    self._oc_dev_fn_stack = graph._device_function_stack  # pylint: disable=protected-access
+    graph._device_function_stack = self._outer_device_function_stack  # pylint: disable=protected-access
+
+  def _ExitOutsideCompilationScope(self):
+    if not self._outside_compilation_cluster:
+      raise ValueError(
+          "Attempted to exit outside_compilation scope when not in scope")
+    self._outside_compilation_cluster = None
+    self._is_map_outside_compilation = False
+    graph = ops.get_default_graph()
+    graph._device_function_stack = self._oc_dev_fn_stack  # pylint: disable=protected-access
+
+  def Enter(self) -> None:
+    if not self._outer_device_function_stack:
+      # Capture the device function stack at the time of first entry
+      # since that is the stack that will be used outside_compilation.
+      graph = ops.get_default_graph()
+      # pylint: disable=protected-access
+      self._outer_device_function_stack = graph._device_function_stack.copy()
+      # pylint: enable=protected-access
+    super(TPUReplicateContext, self).Enter()
+
+  def HostComputeCore(self) -> List[Text]:
+    return self._host_compute_core
+
+  def _RemoveExternalControlEdges(
+      self,
+      op: ops.Operation) -> Tuple[List[ops.Operation], List[ops.Operation]]:
+    """Remove any external control dependency on this op."""
+    internal_control_inputs = []
+    external_control_inputs = []
+    for x in op.control_inputs:
+      # pylint: disable=protected-access
+      is_internal_op = False
+      ctxt = x._get_control_flow_context()
+      while ctxt is not None:
+        if ctxt == self:
+          is_internal_op = True
+          break
+        ctxt = ctxt._outer_context
+      if is_internal_op:
+        internal_control_inputs.append(x)
+      else:
+        external_control_inputs.append(x)
+      # pylint: enable=protected-access
+    # pylint: disable=protected-access
+    op._remove_all_control_inputs()
+    op._add_control_inputs(internal_control_inputs)
+    # pylint: enable=protected-access
+    return internal_control_inputs, external_control_inputs
+
+  def AddOp(self, op: ops.Operation) -> None:
+    # pylint: disable=protected-access
+    if op.type in _DENYLISTED_OPS:
+      logging.error(
+          "Operation of type %s (%s) is not supported on the TPU. "
+          "Execution will fail if this op is used in the graph. ", op.type,
+          op.name)
+
+    if op.type in _UNSUPPORTED_OPS:
+      self._unsupported_ops.append(op)
+
+    if any(x.dtype._is_ref_dtype for x in op.inputs):
+      raise NotImplementedError(
+          f"Non-resource Variables are not supported inside TPU computations "
+          f"(operator name: {op.name})")
+
+    # TensorFlowOpLayer may clone nodes that are in tpu.rewrite()s. It'll add
+    # the "_cloned" attribute and we should continue in that case.
+    if (_TPU_REPLICATE_ATTR in op.node_def.attr and
+        "_cloned" not in op.node_def.attr):
+      raise ValueError(f"TPU computations cannot be nested on op ({op})")
+    op._set_attr(_TPU_REPLICATE_ATTR, self._tpu_replicate_attr)
+    if self._outside_compilation_cluster:
+      op._set_attr(
+          _OUTSIDE_COMPILATION_ATTR,
+          attr_value_pb2.AttrValue(
+              s=compat.as_bytes(self._outside_compilation_cluster)))
+    if self._is_map_outside_compilation:
+      op._set_attr(
+          _MAP_OUTSIDE_COMPILATION_ATTR,
+          attr_value_pb2.AttrValue(b=True),
+      )
+    if self._num_replicas > 1 or not self._outside_compilation_cluster:
+      # Prevent feeding or fetching anything that is being compiled,
+      # and any replicated outside_compilation Op.
+      op.graph.prevent_feeding(op)
+      op.graph.prevent_fetching(op)
+
+    # Remove any control edges from outer control flow contexts. These may cause
+    # mismatched frame errors.
+    (internal_control_inputs,
+     external_control_inputs) = self._RemoveExternalControlEdges(op)
+
+    if not op.inputs:
+      # Add a control edge from the control pivot to this op.
+      if not internal_control_inputs:
+        # pylint: disable=protected-access
+        op._add_control_input(self.GetControlPivot())
+        # pylint: enable=protected-access
+    else:
+      for index in range(len(op.inputs)):
+        x = op.inputs[index]
+        real_x = self.AddValue(x)
+        if real_x is not x:
+          op._update_input(index, real_x)  # pylint: disable=protected-access
+
+    if external_control_inputs:
+      # Use an identity to pull control inputs as data inputs. Note that we
+      # ignore ops which don't have outputs. TODO(phawkins): fix that.
+      with ops.control_dependencies(None):
+        self.Enter()
+        external_control_inputs = [
+            array_ops.identity(x.outputs[0]).op
+            for x in external_control_inputs
+            if x.outputs
+        ]
+        self.Exit()
+      # pylint: disable=protected-access
+      op._add_control_inputs(external_control_inputs)
+      # pylint: enable=protected-access
+
+    # Mark op's outputs as seen by this context and any outer contexts.
+    output_names = [x.name for x in op.outputs]
+    context = self
+    while context is not None:
+      # pylint: disable=protected-access
+      context._values.update(output_names)
+      context = context._outer_context
+      # pylint: enable=protected-access
+
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+
+  def AddValue(self, val: core_types.Tensor) -> core_types.Tensor:
+    """Add `val` to the current context and its outer context recursively."""
+    if not self._outer_context:
+      return val
+
+    if val.name in self._values:
+      # Use the real value if it comes from outer context.
+      result = self._external_values.get(val.name)
+      return val if result is None else result
+
+    result = val
+    self._values.add(val.name)
+    if self._outer_context:
+      result = self._outer_context.AddValue(val)
+      self._values.add(result.name)
+
+    self._external_values[val.name] = result
+
+    return result
+
+  def AddInnerOp(self, op: ops.Operation):
+    self.AddOp(op)
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+
+  @property
+  def grad_state(self):
+    # Define the gradient loop state associated with the TPUReplicateContext to
+    # be None as the TPUReplicateContext does not get nested nor does the
+    # grad_state outside the TPUReplicateContext affect the graph inside so the
+    # grad_state should be as if this is the top-level gradient state.
+    return None
+
+  @property
+  def back_prop(self):
+    """Forwards to the enclosing while context, if any."""
+    if self.GetWhileContext():
+      return self.GetWhileContext().back_prop
+    return False
+
+  def GetControlPivot(self) -> ops.Operation:
+    return self._pivot
+
+  def RequiresUniqueFunctionRetracing(self):
+    # More context: b/158152827. TPU stack uses the TPUReplicateContext to
+    # create replicated variable handles and cluster TPU computations, thus we
+    # always retrace a tf.function when the wrapped TPUReplicateContext changes.
+    return True
+
+
+def _enclosing_tpu_context_and_graph() -> Tuple[Any, Any]:
+  """Returns the TPUReplicateContext and its associated graph."""
+  graph = ops.get_default_graph()
+  while graph is not None:
+    # pylint: disable=protected-access
+    context_ = graph._get_control_flow_context()
+    # pylint: enable=protected-access
+    while context_ is not None:
+      if isinstance(context_, TPUReplicateContext):
+        return context_, graph
+      context_ = context_.outer_context
+    graph = getattr(graph, "outer_graph", None)
+  raise ValueError("get_replicated_var_handle() called without "
+                   "TPUReplicateContext. This shouldn't happen. Please file "
+                   "a bug.")
+
+
+class OutsideCompilationV2Context(control_flow_ops.ControlFlowContext):
+  """The context for outside compilation in Tensorflow 2.0.
+
+  Every op added in this context will be assigned an _xla_outside_compilation
+  attribute.
+  """
+
+  def __init__(self, name: Text, is_map_outside_compilation=False):
+    control_flow_ops.ControlFlowContext.__init__(self)
+    self._name = name
+    self._is_map_outside_compilation = is_map_outside_compilation
+
+  def AddOp(self, op: ops.Operation) -> None:
+    if self._outer_context:
+      self._outer_context.AddOp(op)
+    self._set_outside_compilation_attributes(op)
+
+  def AddInnerOp(self, op: ops.Operation) -> None:
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+    self._set_outside_compilation_attributes(op)
+
+  def to_control_flow_context_def(self, context_def, export_scope=None):
+    raise NotImplementedError
+
+  def _set_outside_compilation_attributes(self, op: ops.Operation) -> None:
+    # pylint: disable=protected-access
+    op._set_attr(
+        _OUTSIDE_COMPILATION_ATTR,
+        attr_value_pb2.AttrValue(s=compat.as_bytes(self._name)),
+    )
+    if self._is_map_outside_compilation:
+      op._set_attr(
+          _MAP_OUTSIDE_COMPILATION_ATTR, attr_value_pb2.AttrValue(b=True)
+      )
+    # pylint: enable=protected-access
+
+
+def outside_compilation_impl(
+    is_map, computation: Callable[..., Any], *args, **kwargs
+) -> Any:
+  """Tags ops in `computation` with outside compilation attributes for ordinary `outside_compilation` or `map_outside_compilation`."""
+  args = [] if args is None else args
+  graph = ops.get_default_graph()
+
+  # If we are in TF 2 functions (control flow V2 functions, or tf.function()),
+  # we need to attach _xla_outside_compilation attribute directly because we are
+  # not in TPUReplicateContext.
+  if isinstance(graph, func_graph.FuncGraph):
+    try:
+      tpu_context, _ = _enclosing_tpu_context_and_graph()
+    except ValueError:
+      logging.warning(
+          "Outside compilation attempted outside TPUReplicateContext "
+          "scope. As no enclosing TPUReplicateContext can be found, "
+          "returning the result of `computation` as is."
+      )
+      return computation(*args, **kwargs)
+
+    # pylint: disable=protected-access
+    outside_compilation_name = str(tpu_context._outside_compilation_counter)
+    tpu_context._outside_compilation_counter = (
+        tpu_context._outside_compilation_counter + 1
+    )
+    # pylint: enable=protected-access
+
+    outside_compilation_context = OutsideCompilationV2Context(
+        outside_compilation_name, is_map_outside_compilation=is_map
+    )
+    outside_compilation_context.Enter()
+    args = [] if args is None else args
+    retval = computation(*args, **kwargs)
+    outside_compilation_context.Exit()
+    return retval
+
+  # If we are in a TPUReplicateContext, signal that we are now
+  # outside_compilation
+  initial_context = graph._get_control_flow_context()  # pylint: disable=protected-access
+  context = initial_context
+  while context:
+    if isinstance(context, TPUReplicateContext):
+      context._EnterOutsideCompilationScope(is_map_outside_compilation=is_map)  # pylint: disable=protected-access
+    context = context.outer_context
+
+  retval = computation(*args, **kwargs)
+
+  # If we are in a TPUReplicateContext, signal that we are no longer
+  # outside_compilation
+  final_context = graph._get_control_flow_context()  # pylint: disable=protected-access
+  if initial_context is not final_context:
+    raise NotImplementedError(
+        "Control-flow context cannot be different at start and end of an "
+        "outside_compilation scope"
+    )
+  context = initial_context
+  while context:
+    if isinstance(context, TPUReplicateContext):
+      context._ExitOutsideCompilationScope()  # pylint: disable=protected-access
+    context = context.outer_context
+
+  return retval
+
+
+@tf_export(v1=["tpu.outside_compilation"])
+def outside_compilation(
+    computation: Callable[..., Any], *args, **kwargs
+) -> Any:
+  """Builds part of a computation outside any current TPU replicate scope.
+
+  `tf.tpu.outside_compilation()` is used to run ops in `computation` on CPU
+  instead of running on TPU. For example, users can run ops that are not
+  supported on TPU's (e.g. tf.summary.write()) by explicitly placing those
+  ops on CPU's. Below usage of outside compilation will place ops in
+  `computation_with_string_ops` on CPU.
+
+  Example usage:
+
+  ```python
+  def computation_with_string_ops(x):
+    # strings types are not supported on TPU's and below ops must
+    # run on CPU instead.
+    output = tf.strings.format('1{}', x)
+    return tf.strings.to_number(output)
+
+  def tpu_computation():
+    # Expected output is 11.
+    output = tf.tpu.outside_compilation(computation_with_string_ops, 1)
+  ```
+
+  Outside compilation should be called inside TPUReplicateContext. That is,
+  `tf.tpu.outside_compilation()` should be called inside a function that is
+  passed to `tpu.split_compile_and_replicate()` -- this is implied when
+  outside compilation is invoked inside a function passed to TPUStrategy
+  `run()`. If invoked outside of TPUReplicateContext,
+  then this simply returns the result of `computation`, and therefore,
+  would be a no-op. Note that outside compilation is different from
+  `tf.distribute.experimental.TPUStrategy.merge_call()` as logic in
+  outside compilation is replicated and executed separately for each
+  replica. On the other hand, `merge_call()` requires a `merge_fn`
+  to aggregate the inputs from different replicas and is executed only
+  once.
+
+  For variables placed in TPU device, which includes variables created inside
+  TPUStrategy scope, outside compilation logic must not include variable
+  read/write. For variables placed on host, which is the case when variables
+  created via TPUEstimator, variable read/write is only allowed if the variable
+  is not accessed by any other ops in the TPU computation. Variable read/write
+  from outside compilation cluster is not visible from TPU computation and
+  vice versa. Therefore, if outside compilation logic contains such host
+  variables read/write ops and if the variables are accessed by TPU
+  computation as well, then this may lead to deadlock.
+
+  Internally, `tf.tpu.outside_compilation()` adds outside compilation
+  attributes to all ops in `computation`. During a later passes ops with outside
+  compilation attributes are moved to a host-side graph. Inputs to this extract
+  host-side graph are sent from TPU computation graph to host graph via a pair
+  of XlaSendToHost and XlaRecvFromHost ops. Note that using
+  `tf.tpu.outside_compilation()` may result in tensor transfer between TPU and
+  CPU, leading to non-trivial performance impact.
+
+  Args:
+    computation: A Python function that builds the computation to place on the
+      host.
+    *args: the positional arguments for the computation.
+    **kwargs: the keyword arguments for the computation.
+
+  Returns:
+    The Tensors returned by computation.
+  """
+  return outside_compilation_impl(False, computation, *args, **kwargs)
+
+
+def experimental_map_outside_compilation(
+    computation: Callable[..., Any], *args, **kwargs
+) -> Any:
+  """Maps `computation` onto shards and puts it outside any current TPU replicate scope.
+
+  `experimental_map_outside_compilation(f, x)` maps `f` onto the shards
+  of `x`, where `x` is split-sharded. Each invocation of `f` on a split occurs
+  on the CPU that's associated with the TPU that owns the split.
+
+  Example usage:
+
+  ```python
+  def normalize_each_split(split):
+    return split - tf.math.reduce_mean(split)
+
+  def tpu_computation(x):
+    x_split = strategy.experimental_split_to_logical_devices(
+                x, [num_cores_per_replica, 1])
+    y = experimental_map_outside_compilation(
+          normalize_each_split, x_split)
+    y_split = strategy.experimental_split_to_logical_devices(
+                x, [num_cores_per_replica, 1])
+    return y_split
+  ```
+
+  `experimental_map_outside_compilation` should be called inside
+  TPUReplicateContext. That is, `outside_compilation()` should be called
+  inside a function that is passed to `tpu.split_compile_and_replicate()` --
+  this is implied when outside compilation is invoked inside a function passed
+  to TPUStrategy `run()`. It is invalid to invoke outside of
+  TPUReplicateContext.
+
+  `experimental_map_outside_compilation` should input and output tensors that
+  are located on the TPU.
+
+  Internally, `experimental_map_outside_compilation()` adds outside
+  compilation attributes to all ops in `computation` and moves outside-compiled
+  ops to a host-side graph. This is similar to `tf.tpu.outside_compilation()`.
+  Send/recv ops from/to the TPU send each split directly to the TPU's host.
+
+  Args:
+    computation: A Python function that builds the computation to place on the
+      host.
+    *args: the positional arguments for the computation.
+    **kwargs: the keyword arguments for the computation.
+
+  Returns:
+    The Tensors returned by computation.
+  """
+  return outside_compilation_impl(True, computation, *args, **kwargs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/tpu_sharding.py

@@ -0,0 +1,302 @@
+# 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.
+# =============================================================================
+"""Helper library for sharding during TPU compilation."""
+
+
+from tensorflow.python.framework import tensor_shape
+
+_DEFAULT_NUMBER_OF_SHARDS = 1
+_DEFAULT_SHARD_DIMENSION = 0
+
+
+# TODO(b/36777903) change other parts of tpu.py to use this class.
+class ShardingPolicy(object):
+  """An object use to hold the sharding policy for a Tensor."""
+
+  def __init__(self):
+    self._number_of_shards = None
+    self._number_of_partitions = 1
+    self._shard_dimension = None
+    self._frozen = False
+
+  def __str__(self):
+    if self.number_of_shards is None or self.shard_dimension is None:
+      return "ShardingPolicy(unset)"
+    else:
+      return ("ShardingPolicy(%d shards dimension %d)" %
+              (self.number_of_shards, self.shard_dimension))
+
+  def _fill_default_values(self):
+    if self._number_of_shards is None:
+      self._number_of_shards = _DEFAULT_NUMBER_OF_SHARDS
+    if self._shard_dimension is None:
+      self._shard_dimension = tensor_shape.as_dimension(
+          _DEFAULT_SHARD_DIMENSION)
+
+  def freeze(self):
+    """Prevents further modification to the sharding policy.
+
+    Any values that have not been set when freeze is called are set to
+    defaults. If the ShardingPolicy is already frozen, this is a NoOp.
+    """
+    if not self._frozen:
+      self._fill_default_values()
+      self._frozen = True
+
+  @property
+  def number_of_shards(self):
+    """Returns the number of shards in the policy or None if unspecified."""
+    return self._number_of_shards
+
+  def set_number_of_shards(self, number_of_shards):
+    """Sets the number of shards for the current policy.
+
+    If the policy has been frozen then number_of_shards must match the
+    existing setting.
+
+    Args:
+      number_of_shards: The number of shards to use in the policy.
+
+    Raises:
+      ValueError: If the policy has been frozen and number_of_shards
+        differs from the frozen value; or number_of_shards <= 0.
+    """
+    if self._frozen:
+      if self._number_of_shards != number_of_shards:
+        raise ValueError(
+            f"Can't set sharding policy to use {number_of_shards} shards since "
+            f"it has been frozen to use {self._number_of_shards}")
+    else:
+      if number_of_shards > 0:
+        self._number_of_shards = number_of_shards
+      else:
+        raise ValueError(
+            f"Can't set sharding policy to use {number_of_shards} shards; "
+            "value must be > 0")
+
+  @property
+  def number_of_partitions(self):
+    """Returns the number of partitions of the policy or None if unspecified."""
+    return self._number_of_partitions
+
+  def set_number_of_partitions(self, number_of_partitions):
+    """Sets the number of partitions for the current policy.
+
+    If the policy has been frozen then shard_dimension must match the
+    existing setting.
+
+    Args:
+      number_of_partitions: The number of partitions to use in the policy.
+
+    Raises:
+      ValueError: If the policy has been frozen and shard_dimension
+        differs from the frozen value.
+    """
+    if self._frozen:
+      if self._number_of_partitions != number_of_partitions:
+        raise ValueError(
+            f"Can't set number_of_partitions to {number_of_partitions} since "
+            f"it has been frozen to use {self._number_of_partitions}.")
+    else:
+      self._number_of_partitions = number_of_partitions
+
+  @property
+  def shard_dimension(self):
+    """Returns the shard dimension of the policy or None if unspecified."""
+    return self._shard_dimension
+
+  def set_shard_dimension(self, shard_dimension):
+    """Sets the shard dimension for the current policy.
+
+    If the policy has been frozen then shard_dimension must match the
+    existing setting.
+
+    Args:
+      shard_dimension: The shard dimension to use in the policy.
+
+    Raises:
+      ValueError: If the policy has been frozen and shard_dimension
+        differs from the frozen value, or shard_dimension can't be
+        interpreted as a Dimension.
+    """
+    if self._frozen:
+      if self._shard_dimension != shard_dimension:
+        raise ValueError(
+            "Can't set shard dimension to %d since it has been frozen to "
+            "use %d." % (shard_dimension, self._shard_dimension))
+    else:
+      self._shard_dimension = tensor_shape.as_dimension(shard_dimension)
+
+  def merge(self, other):
+    """Merges the policy of another policy into the current policy.
+
+    Args:
+      other: The policy to merge into this one.
+
+    Raises:
+      ValueError: If this policy has been frozen and the merge conflicts with
+      the frozen policy.
+    """
+    if other.number_of_shards is not None:
+      self.set_number_of_shards(other.number_of_shards)
+    if other.shard_dimension is not None:
+      self.set_shard_dimension(other.shard_dimension)
+
+  def get_unpartitioned_shape(self, shape):
+    """Returns the shape of an unpartitioned Tensor.
+
+    When given the shape of a 'sharded-size' Tensor, returns the shape
+    of the full shape of its unpartitioned Tensor.
+
+    Args:
+      shape: The shape of the sharded Tensor.
+
+    Returns:
+      The shape of the unpartitioned version of the Tensor.
+
+    Raises:
+      ValueError: if shape has unknown sharded dimension
+    """
+    shape = tensor_shape.as_shape(shape)
+    dims = shape.as_list()
+    if (self._shard_dimension is None or self._number_of_partitions is None or
+        not dims):
+      return None
+    if dims[self._shard_dimension] is None:
+      raise ValueError(f"Shape {shape.as_list()} must have a fixed size for "
+                       f"dimension {self._shard_dimension} that is known. ")
+    if self._number_of_partitions > 1:
+      dims[self._shard_dimension] *= self._number_of_partitions
+    return tensor_shape.as_shape(dims)
+
+  def get_sharded_shape(self, shape, shard_index=None):
+    """Returns the shape of a shard of a full Tensor.
+
+    When given the shape of a 'full-size' Tensor, returns the shape of
+    the sub-Tensor after it has been sharded. Freezes the policy if it
+    has not yet been frozen.
+
+    Args:
+      shape: The shape of the full-size Tensor to be sharded.
+      shard_index: The index of the shard whose shape should be returned.
+        shard_index can be None for sharding policies that use the same shape
+        for every shard.
+
+    Returns:
+      The shape of the sharded version of the Tensor.
+
+    Raises:
+      ValueError: If shard_index is None when shards are of different
+        shapes; or shard_index is not None and
+        !(0<=shard_index<number_of_shards); or shape does not have at
+        least self.shard_dimension+1 dimensions; or the value of
+        shape's shard dimension is not a multiple of
+        self.number_of_shards
+    """
+    if self._shard_dimension is None or self._number_of_shards is None:
+      # Don't raise an error if the config is unset.
+      return None
+    if shard_index is not None:
+      if shard_index < 0 or shard_index >= self.number_of_shards:
+        raise ValueError(
+            f"Requested shard_index {shard_index}, but shard_index must be in "
+            f"[0,{self._number_of_shards}).")
+    shape = tensor_shape.as_shape(shape)
+    if self._number_of_shards == 1:
+      # Don't do anything when there's only one shard.
+      return shape
+    ndims = shape.ndims
+    if ndims is None:
+      raise ValueError(f"Shape {shape} must be a known shape.")
+    if ndims <= self._shard_dimension:
+      raise ValueError(
+          f"Shape {shape.as_list()} does not contain shard_dimension "
+          f"{self._shard_dimension}")
+    dims = shape.as_list()
+    if dims[self._shard_dimension] is None:
+      raise ValueError(
+          f"Shape {shape.as_list()} must have a fixed size for dimension "
+          f"{self._shard_dimension} that is known at construction time.")
+    if (dims[self._shard_dimension] % self._number_of_shards) != 0:
+      raise ValueError(
+          f"Shape {shape.as_list()} cannot be sharded {self._number_of_shards} "
+          f"ways along dimension {self._shard_dimension}")
+    dims[self._shard_dimension] //= self._number_of_shards
+    return tensor_shape.TensorShape(dims)
+
+  def _unshard_shape(self, shape):
+    """Return the unsharded shape that would generate a given sharded shape.
+
+    Args:
+      shape: the sharded shape to unshard
+
+    Returns:
+      The unsharded shape.
+
+    Raises:
+      ValueError: if shape is unknown or does not contain
+        self.shard_dimension
+      TypeError: if shape is not convertible to a TensorShape
+    """
+    shape = tensor_shape.as_shape(shape)
+    if self._number_of_shards == 1:
+      # Don't do anything when there's only one shard.
+      return shape
+    ndims = shape.ndims
+    if ndims is None:
+      raise ValueError(f"Shape {shape} must be statically known.")
+    if ndims <= self._shard_dimension:
+      raise ValueError(f"Shape {shape.as_list()} does not contain "
+                       f"shard_dimension {self._shard_dimension}. "
+                       f"Rank is too small.")
+    dims = shape.as_list()
+    dims[self._shard_dimension] *= self._number_of_shards
+    return tensor_shape.TensorShape(dims)
+
+  def get_unsharded_shape(self, shapes):
+    """Returns the shape of an unsharded Tensor given a list of shards.
+
+    When given a list of shapes of shards, returns the shape of the
+    unsharded Tensor that would generate the shards. Sets defaults for the
+    policy if number_of_shards or shard_dimension is None.
+
+    Args:
+      shapes: The shapes of the Tensor shards to be combined.
+
+    Returns:
+      The shape of the unsharded version of the Tensor.
+
+    Raises:
+      ValueError: if shapes is not a list of length
+        self.number_of_shards; or any element of shapes is not a valid
+        shape consistent with the sharding policy; or the list of
+        shapes is not a valid sharding of a full shape.
+      TypeError: if an element of shapes is not convertible to a
+        TensorShape
+    """
+    self._fill_default_values()
+    if len(shapes) != self.number_of_shards:
+      raise ValueError(
+          f"Shapes {shapes} is length {len(shapes)} but must be a list of "
+          f"length number_of_shards={self.number_of_shards}")
+    unsharded_shapes = [self._unshard_shape(s) for s in shapes]
+    for i in range(self.number_of_shards - 1):
+      if not unsharded_shapes[i].is_compatible_with(
+          unsharded_shapes[self.number_of_shards - 1]):
+        raise ValueError(
+            f"Sharded shapes {shapes} are not consistent shards of a full shape "
+            f"sharded {self.number_of_shards} ways along "
+            f"dimension {self.shard_dimension}.")
+    return unsharded_shapes[0]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/tpu_strategy_util.py

@@ -0,0 +1,305 @@
+# 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.
+# ==============================================================================
+"""TPU specific APIs to be used in conjunction with TPU Strategy."""
+
+import gc
+
+from tensorflow.core.protobuf import config_pb2
+from tensorflow.python.client import session as session_lib
+from tensorflow.python.distribute.cluster_resolver import cluster_resolver as cluster_resolver_lib
+from tensorflow.python.eager import context
+from tensorflow.python.eager import def_function
+from tensorflow.python.eager import monitoring
+from tensorflow.python.framework import device
+from tensorflow.python.framework import errors
+from tensorflow.python.framework import ops
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.tpu import topology
+from tensorflow.python.tpu import tpu
+from tensorflow.python.util import compat
+
+
+_INITIALIZED_TPU_SYSTEMS = {}
+_LOCAL_MASTERS = ("", "local")
+
+
+_tpu_worker_address = monitoring.StringGauge(
+    "/tensorflow/tpu/worker_address",
+    "The worker address that the coordinator/client connects to.", "address")
+
+
+def initialize_tpu_system_impl(cluster_resolver, tpu_cluster_resolver_cls):
+  """Implementation for tpu.experimental.initialize_tpu_system.
+
+  Kept separate to avoid tpu_oss code duplication.
+
+  Initialize the TPU devices.
+
+  Args:
+    cluster_resolver: A tf.distribute.cluster_resolver.TPUClusterResolver,
+        which provides information about the TPU cluster.
+    tpu_cluster_resolver_cls: a reference to
+        tf.distribute.cluster_resolver.TPUClusterResolver so that an instance
+        of it can be initialized if cluster_resolver is None.
+  Returns:
+    The tf.tpu.Topology object for the topology of the TPU cluster. If called
+    inside tf.function, it returns the serialized topology object instead.
+
+  Raises:
+    RuntimeError: If running inside a tf.function.
+    NotFoundError: If no TPU devices found in eager mode.
+    TypeError: If tpu_cluster_resolver_cls is
+        not tf.distribute.cluster_resolver.TPUClusterResolver.
+  """
+  # check that tpu_cluster_resolver_cls is a
+  # tf.distribute.cluster_resolver.TPUClusterResolver
+  if tpu_cluster_resolver_cls is None or not issubclass(
+      tpu_cluster_resolver_cls, cluster_resolver_lib.ClusterResolver
+  ) or not hasattr(tpu_cluster_resolver_cls, "tpu_hardware_feature"):
+    raise TypeError(
+        "tpu_cluster_resolver_cls is not"
+        " tf.distribute.cluster_resolver.TPUClusterResolver.")
+  # Deallocate all TPU buffers by clearing out eager context caches and
+  # triggering garbage collection to avoid keeping invalid tpu buffer around
+  # after reinitialized tpu system.
+  logging.info("Deallocate tpu buffers before initializing tpu system.")
+  context.context()._clear_caches()  # pylint: disable=protected-access
+  context.context().clear_kernel_cache()
+  gc.collect()
+
+  job = None
+  if cluster_resolver is None:
+    # If no cluster resolver is specified, and running eagerly, execute the init
+    # ops in the current device scope.
+    if context.executing_eagerly():
+      curr_device = device.DeviceSpec.from_string(context.context().device_name)
+      if curr_device.job is not None:
+        job = "{}/replica:0/task:0".format(curr_device.job)
+
+    cluster_resolver = tpu_cluster_resolver_cls("")
+  assert isinstance(cluster_resolver, tpu_cluster_resolver_cls)
+
+  tpu_name = compat.as_text(cluster_resolver._tpu)  # pylint: disable=protected-access
+  if tpu_name in _INITIALIZED_TPU_SYSTEMS:
+    logging.warning(
+        "TPU system %s has already been initialized. "
+        "Reinitializing the TPU can cause previously created "
+        "variables on TPU to be lost.", tpu_name)
+
+  logging.info("Initializing the TPU system: %s", tpu_name)
+
+  # This function looks as it is for the following non-intuitive reasons.
+  # tpu.initialize_system creates a dummy op whose sole purpose is to trigger
+  # DistributedTPURewritePass. This pass actually adds real ops that
+  # initialize the TPU system. Thus, we can't simply run tpu.initialize_system
+  # eagerly. We need to wrap it in defun and trigger the rewrite passes on it.
+  if tpu_name not in _LOCAL_MASTERS:
+    # Explicitly place the tpu.initialize_system in the first worker to
+    # avoid the output node match multiple devices error.
+    job = "{}/replica:0/task:0".format(cluster_resolver.get_job_name())
+
+  if context.executing_eagerly():
+    @def_function.function(autograph=False)
+    def _tpu_init_fn():
+      # In TF1, we usually close chips when compilation fails to clear the data
+      # in infeed. In TF2, we don't need to do this because infeed is no longer
+      # used, so user can recover from TPU compilation failures more smoothly.
+      # Same for the cancellation of a TPU excution.
+      return tpu.initialize_system(
+          job=job,
+          compilation_failure_closes_chips=False,
+          tpu_cancellation_closes_chips=False)
+
+    # The TPU_SYSTEM device must match the device used in tpu.initialize_system
+    # exactly, otherwise you can get errors if there are multiple TPU_SYSTEM
+    # devices available.
+    run_eagerly = def_function.functions_run_eagerly()
+    if run_eagerly:
+      logging.warning(
+          "It looks like tf.function behavior was disabled, perhaps using"
+          " tf.config.run_functions_eagerly."
+          " tf.tpu.experimental.initialize_tpu_system requires tf.function to"
+          " work. This primitive will override the disable."
+      )
+      def_function.run_functions_eagerly(False)
+    try:
+      with ops.device(tpu._tpu_system_device_name(job)):  # pylint: disable=protected-access
+        output = _tpu_init_fn()
+      context.async_wait()
+    except errors.InvalidArgumentError as e:
+      raise errors.NotFoundError(
+          None, None,
+          "TPUs not found in the cluster. Failed in initialization: "
+          + str(e))
+    finally:
+      if run_eagerly is not None:
+        def_function.run_functions_eagerly(run_eagerly)
+    # Clear out the eager context caches since the memory is invalid now.
+    context.context()._initialize_logical_devices()  # pylint: disable=protected-access
+
+    serialized_topology = output.numpy()
+  elif not ops.executing_eagerly_outside_functions():
+    master = cluster_resolver.master()
+    cluster_spec = cluster_resolver.cluster_spec()
+
+    session_config = config_pb2.ConfigProto(allow_soft_placement=True)
+    if cluster_spec:
+      session_config.cluster_def.CopyFrom(cluster_spec.as_cluster_def())
+
+    with ops.Graph().as_default():
+      with session_lib.Session(config=session_config, target=master) as sess:
+        serialized_topology = sess.run(tpu.initialize_system())
+  else:
+    with ops.device(tpu._tpu_system_device_name(job)):  # pylint: disable=protected-access
+      serialized_topology = tpu.initialize_system(
+          job=job, compilation_failure_closes_chips=False)
+      # If initialize_tpu_system is called inside tf.function, we only return
+      # the serialized topology object as the tf.tpu.Topology object has to be
+      # constructed in eager mode.
+      return serialized_topology
+
+  logging.info("Finished initializing TPU system.")
+  tpu_topology = topology.Topology(serialized=serialized_topology)
+  cluster_resolver.set_tpu_topology(serialized_topology)
+  _INITIALIZED_TPU_SYSTEMS[tpu_name] = tpu_topology
+
+  # Record the address of the TPU worker-0 that the coordinator connects to.
+  # This can be used to associate the TPU worker with the right coordinator when
+  # aggregating the metrics for the application. An example of the address:
+  # /bns/mb/borg/mb/bns/chienchunh/chienchunh_group_49640234.1.tfm_train_tpu_worker/0
+  _tpu_worker_address.get_cell("address").set(cluster_resolver.get_master())
+
+  return tpu_topology
+
+
+def get_initialized_tpu_systems():
+  """Returns all currently initialized tpu systems.
+
+  Returns:
+     A dictionary, with tpu name as the key and the tpu topology as the value.
+  """
+  return _INITIALIZED_TPU_SYSTEMS.copy()
+
+
+def shutdown_tpu_system_impl(cluster_resolver, tpu_cluster_resolver_cls):
+  """Implementation for tpu.experimental.shutdown_tpu_system.
+
+  Kept separate to avoid tpu_oss code duplication.
+
+  Shuts down the TPU devices.
+
+  This will clear all caches, even those that are maintained through sequential
+  calls to tf.tpu.experimental.initialize_tpu_system, such as the compilation
+  cache.
+
+  Args:
+    cluster_resolver: A tf.distribute.cluster_resolver.TPUClusterResolver,
+        which provides information about the TPU cluster.
+    tpu_cluster_resolver_cls: a reference to
+        tf.distribute.cluster_resolver.TPUClusterResolver so that an instance
+        of it can be initialized if cluster_resolver is None.
+
+  Raises:
+    RuntimeError: If no TPU devices found for eager execution or if run in a
+        tf.function.
+    TypeError: If tpu_cluster_resolver_cls is
+        not tf.distribute.cluster_resolver.TPUClusterResolver.
+  """
+  # check that tpu_cluster_resolver_cls is a
+  # tf.distribute.cluster_resolver.TPUClusterResolver
+  if tpu_cluster_resolver_cls is None or not issubclass(
+      tpu_cluster_resolver_cls, cluster_resolver_lib.ClusterResolver
+  ) or not hasattr(tpu_cluster_resolver_cls, "tpu_hardware_feature"):
+    raise TypeError(
+        "tpu_cluster_resolver_cls is not"
+        " tf.distribute.cluster_resolver.TPUClusterResolver.")
+
+  job = None
+  if cluster_resolver is None:
+    # If no cluster resolver is specified, and running eagerly, execute the init
+    # ops in the current device scope.
+    if context.executing_eagerly():
+      curr_device = device.DeviceSpec.from_string(context.context().device_name)
+      if curr_device.job is not None:
+        job = "{}/replica:0/task:0".format(curr_device.job)
+
+    cluster_resolver = tpu_cluster_resolver_cls("")
+  assert isinstance(cluster_resolver, tpu_cluster_resolver_cls)
+
+  tpu_name = compat.as_text(cluster_resolver._tpu)  # pylint: disable=protected-access
+  if tpu_name not in _INITIALIZED_TPU_SYSTEMS:
+    logging.warning("You are shutting down a TPU system %s that has not been "
+                    "initialized." % tpu_name)
+
+  logging.info("Shutting down the TPU system: %s", tpu_name)
+
+  if context.executing_eagerly():
+    # This function looks as it is for the following non-intuitive reasons.
+    # tpu.shutdown_system creates a dummy op whose sole purpose is to trigger
+    # DistributedTPURewritePass. This pass actually adds real ops that
+    # shutdown the TPU system. Thus, we can't simply run tpu.shutdown_system
+    # eagerly. We need to wrap it in defun and trigger the rewrite passes on it.
+    if tpu_name not in _LOCAL_MASTERS:
+      # Explicitly place the tpu.shutdown_system in the first worker to
+      # avoid the output node match multiple devices error.
+      job = "{}/replica:0/task:0".format(cluster_resolver.get_job_name())
+
+    @def_function.function(autograph=False)
+    def _tpu_shutdown_fn():
+      tpu.shutdown_system(job=job)
+
+    # The TPU_SYSTEM device must match the device used in tpu.shutdown_system
+    # exactly, otherwise you can get errors if there are multiple TPU_SYSTEM
+    # devices available.
+    run_eagerly = def_function.functions_run_eagerly()
+    if run_eagerly:
+      logging.warning(
+          "It looks like tf.function behavior was disabled, perhaps using"
+          " tf.config.run_functions_eagerly."
+          " tf.tpu.experimental.shutdown_tpu_system requires tf.function to"
+          " work. This primitive will override the disable."
+      )
+      def_function.run_functions_eagerly(False)
+    try:
+      with ops.device(tpu._tpu_system_device_name(job)):  # pylint: disable=protected-access
+        _tpu_shutdown_fn()
+    finally:
+      if run_eagerly is not None:
+        def_function.run_functions_eagerly(run_eagerly)
+
+    # Clear out the eager context caches since the memory is invalid now.
+    logging.info("Clearing out eager caches")
+    context.context()._clear_caches()  # pylint: disable=protected-access
+    context.context().clear_kernel_cache()
+  elif not ops.executing_eagerly_outside_functions():
+    master = cluster_resolver.master()
+    cluster_spec = cluster_resolver.cluster_spec()
+
+    session_config = config_pb2.ConfigProto(allow_soft_placement=True)
+    if cluster_spec:
+      session_config.cluster_def.CopyFrom(cluster_spec.as_cluster_def())
+
+    with ops.Graph().as_default():
+      with session_lib.Session(config=session_config, target=master) as sess:
+        sess.run(tpu.shutdown_system())
+  else:
+    raise RuntimeError(
+        "initialize_tpu_system is not supported within "
+        "tf.functions.  You should call initialize_tpu_system outside of your tf.function. "
+    )
+
+  logging.info("Finished shutting down TPU system.")
+  if tpu_name in _INITIALIZED_TPU_SYSTEMS:
+    del _INITIALIZED_TPU_SYSTEMS[tpu_name]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/tpu_system_metadata.py

@@ -0,0 +1,227 @@
+# 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.
+# ===================================================================
+"""TPU system metadata and associated tooling."""
+
+import collections
+
+from tensorflow.core.protobuf import config_pb2
+from tensorflow.python.client import session as session_lib
+from tensorflow.python.distribute import device_util
+from tensorflow.python.eager import context
+from tensorflow.python.framework import config
+from tensorflow.python.framework import device as tf_device
+from tensorflow.python.framework import errors
+from tensorflow.python.framework import ops
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.tpu import tpu
+from tensorflow.python.util.tf_export import tf_export
+
+_PINGING_MASTER_TIMEOUT_IN_MS = 5 * 60 * 1000  # 10 min
+_RETRY_TIMES = 12 * 24  # 1 day
+_INITIAL_TPU_SYSTEM_TIMEOUT_IN_MS = 300 * 1000  # 5 mins
+
+_DEFAULT_JOB_NAME = 'tpu_worker'
+_DEFAULT_COORDINATOR_JOB_NAME = 'coordinator'
+_LOCAL_MASTERS = ('', 'local')
+
+
+@tf_export('tpu.experimental.TPUSystemMetadata')
+class TPUSystemMetadata(
+    collections.namedtuple('TPUSystemMetadata', [
+        'num_cores',
+        'num_hosts',
+        'num_of_cores_per_host',
+        'topology',
+        'devices',
+    ])):
+  """Describes some metadata about the TPU system.
+
+  Attributes:
+    num_cores: interger. Total number of TPU cores in the TPU system.
+    num_hosts: interger. Total number of hosts (TPU workers) in the TPU system.
+    num_of_cores_per_host: interger. Number of TPU cores per host (TPU worker).
+    topology: an instance of `tf.tpu.experimental.Topology`, which describes the
+      physical topology of TPU system.
+    devices: a tuple of strings, which describes all the TPU devices in the
+      system.
+  """
+
+  def __new__(cls, num_cores, num_hosts, num_of_cores_per_host, topology,
+              devices):
+    return super(TPUSystemMetadata,
+                 cls).__new__(cls, num_cores, num_hosts, num_of_cores_per_host,
+                              topology, devices)
+
+
+def _query_tpu_system_metadata(master_address, cluster_def=None,
+                               query_topology=False):
+  """Automatically detects the TPU system metadata in the system."""
+  tpu_core_count = 0
+  devices = []
+  device_dict = collections.defaultdict(list)
+
+  if context.executing_eagerly():
+    logical_devices = config.list_logical_devices()
+
+    # We want the output type to match in both eager and session mode
+    devices = [session_lib._DeviceAttributes(device_util.canonicalize(d.name),  # pylint: disable=protected-access
+                                             d.device_type, 0, 0)
+               for d in logical_devices]
+  else:
+    # TODO(b/120564445): Replace with standard library for retries.
+    retry_count = 1
+    while True:
+      logging.info('Querying Tensorflow master (%s) for TPU system metadata.',
+                   master_address)
+      try:
+        with ops.Graph().as_default():
+          with session_lib.Session(
+              master_address,
+              config=get_session_config_with_timeout(
+                  _PINGING_MASTER_TIMEOUT_IN_MS,
+                  cluster_def)) as sess:
+            devices = sess.list_devices()
+            break
+      except errors.DeadlineExceededError:
+        msg = ('Failed to connect to the Tensorflow master. The TPU worker may '
+               'not be ready (still scheduling) or the Tensorflow master '
+               'address is incorrect: got (%s).' %
+               (master_address))
+
+        # TODO(xiejw): For local or grpc master we might not need retry logic
+        # here.
+        if retry_count <= _RETRY_TIMES:
+          logging.warning('%s', msg)
+          logging.warning('Retrying (%d/%d).', retry_count, _RETRY_TIMES)
+          retry_count += 1
+        else:
+          raise ValueError(msg)
+
+  for device in devices:
+    spec = tf_device.DeviceSpec.from_string(device.name)
+    if spec.device_type == 'TPU':
+      device_dict[spec.task].append(spec.device_index)
+      tpu_core_count += 1
+
+  num_of_cores_per_host = 0
+  if tpu_core_count:
+    num_cores_per_host_set = set(
+        [len(core_ids) for core_ids in device_dict.values()])
+    if len(num_cores_per_host_set) != 1:
+      raise RuntimeError(
+          'TPU cores on each host is not same. This should not happen!. '
+          'devices: {}'.format(devices))
+    num_of_cores_per_host = num_cores_per_host_set.pop()
+
+  topology = None
+  if query_topology:
+    if not tpu_core_count:
+      raise RuntimeError(
+          'Cannot find any TPU cores in the system (master address {}). '
+          'This usually means the master address is incorrect or the '
+          'TPU worker has some problems. Available devices: {}'.format(
+              master_address, devices))
+
+    topology = _obtain_topology(master_address, cluster_def)
+
+  # We sort the metadata devices so that downstream users get a sorted list
+  # for creating mirrored variables correctly.
+  def _sort_key(device):
+    spec = tf_device.DeviceSpec.from_string(device.name)
+    return (spec.job, spec.replica, spec.task, spec.device_type,
+            spec.device_index)
+  devices = tuple(sorted(devices, key=_sort_key))
+
+  metadata = TPUSystemMetadata(
+      num_cores=tpu_core_count,
+      num_hosts=len(device_dict),
+      num_of_cores_per_host=num_of_cores_per_host,
+      topology=topology,
+      devices=devices)
+
+  if tpu_core_count:
+    logging.info('Found TPU system:')
+    logging.info('*** Num TPU Cores: %d', metadata.num_cores)
+    logging.info('*** Num TPU Workers: %d', metadata.num_hosts)
+    logging.info('*** Num TPU Cores Per Worker: %d',
+                 metadata.num_of_cores_per_host)
+    for device in metadata.devices:
+      logging.info('*** Available Device: %s', device)
+  else:
+    logging.info('Failed to find TPU: %s', metadata)
+  return metadata
+
+
+def _obtain_topology(master_address, cluster_def):
+  """Obtains TPU fabric topology."""
+  try:
+    logging.info('Initializing TPU system (master: %s) to fetch topology '
+                 'for model parallelism. This might take a while.',
+                 master_address)
+    with ops.Graph().as_default():
+      session_config = get_session_config_with_timeout(
+          _INITIAL_TPU_SYSTEM_TIMEOUT_IN_MS, cluster_def)
+      with session_lib.Session(
+          master_address, config=session_config) as sess:
+        topology = sess.run(tpu.initialize_system())
+        return topology
+  except errors.DeadlineExceededError:
+    raise ValueError(
+        'Fail to initialize TPU system with master (%s). '
+        'Please double check the TPU system is functional.' % (
+            master_address))
+
+
+def get_session_config_with_timeout(timeout_in_secs, cluster_def):
+  """Returns a session given a timeout and a cluster configuration."""
+  config_proto = config_pb2.ConfigProto(
+      operation_timeout_in_ms=timeout_in_secs, cluster_def=cluster_def)
+  return config_proto
+
+
+def master_job(master, cluster_def):
+  """Returns the canonical job name to use to place TPU computations on.
+
+  Args:
+    master: A `string` representing the TensorFlow master to use.
+    cluster_def: A ClusterDef object describing the TPU cluster.
+
+  Returns:
+    A string containing the job name, or None if no job should be specified.
+
+  Raises:
+    ValueError: If the user needs to specify a tpu_job_name, because we are
+      unable to infer the job name automatically, or if the user-specified job
+      names are inappropriate.
+  """
+  # If the user specifies the tpu_job_name, use that.
+
+  if master in _LOCAL_MASTERS:
+    return None
+
+  if (not cluster_def or not cluster_def.job):
+    return _DEFAULT_JOB_NAME
+  job_names = set(job.name for job in cluster_def.job)
+  if _DEFAULT_JOB_NAME in job_names:
+    # b/37868888 tracks allowing ClusterSpec propagation to reuse job names.
+    raise ValueError('Currently, tpu_worker is not an allowed job name.')
+  if len(job_names) == 1:
+    return cluster_def.job[0].name
+  if len(job_names) == 2:
+    if _DEFAULT_COORDINATOR_JOB_NAME in job_names:
+      job_names.remove(_DEFAULT_COORDINATOR_JOB_NAME)
+      return job_names.pop()
+    # TODO(b/67716447): Include more sophisticated heuristics.
+  raise ValueError('Could not infer TPU job name.')

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/training_loop.py

@@ -0,0 +1,229 @@
+# 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.
+# =============================================================================
+
+"""Library for constructing a training loop, suitable for TPUs."""
+
+from typing import Any, Callable, Iterable, List, Optional, Union
+
+from tensorflow.python.compiler.xla import xla
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import while_loop as while_loop_tf
+from tensorflow.python.tpu import tensor_tracer
+from tensorflow.python.tpu import tpu_feed
+from tensorflow.python.tpu import tpu_function
+from tensorflow.python.types import core as core_types
+
+
+def while_loop(condition: Callable[..., Any],
+               body: Callable[..., Any],
+               inputs: Optional[List[Any]] = None,
+               infeed_queue: Optional[tpu_feed.InfeedQueue] = None,
+               name: Any = None) -> Any:
+  """Builds a training loop for TPUs.
+
+  The set of loop-carried tensors corresponds to `inputs`.  Both
+  `condition` and `body` take the current value of the loop-carried
+  tensors. 'body' additionally takes a tuple of infeed from
+  infeed_queue if infeed_queue is not None. `condition` must return a
+  single boolean value that determines whether iteration
+  continues. `body` must return an updated list of values for the
+  loop-carried tensors.
+
+  Args:
+    condition: a Python function that builds the loop condition.
+    body: a Python function that builds the loop body.
+    inputs: a list of initial values passed into the training loop, or None
+      (equivalent to an empty list).
+    infeed_queue: if not None, the infeed queue from which to append a tuple of
+      arguments as inputs to condition.
+    name: (Deprecated) Does nothing.
+
+  Returns:
+    The final values of the loop-carried tensors.
+
+  Raises:
+    TypeError: if body or condition has the wrong signature.
+  """
+  del name
+  # Converts inputs to Tensors.
+  inputs = [] if inputs is None else [ops.convert_to_tensor(x) for
+                                      x in inputs]
+  input_types = [x.dtype for x in inputs]
+  input_arity = len(inputs)
+
+  body_arg_error = xla.check_function_argument_count(
+      body, input_arity, infeed_queue)
+  if body_arg_error is not None:
+    if infeed_queue is None:
+      raise TypeError(
+          f"Supplied loop body function cannot be called with the specified "
+          f"inputs. You specified {input_arity} inputs: {[i.name for i in inputs]}, but the loop body needs {body_arg_error}"
+      )
+    else:
+      raise TypeError(
+          f"Supplied loop body function cannot be called with the specified "
+          f"inputs. You specified {input_arity} inputs: {[i.name for i in inputs]} and {infeed_queue.number_of_tuple_elements} additional inputs from "
+          f"infeed, but the computation needs {body_arg_error}")
+  condition_arg_error = xla.check_function_argument_count(
+      condition, input_arity, None)
+  if condition_arg_error is not None:
+    if infeed_queue is None:
+      raise TypeError(
+          f"Supplied loop condition function cannot be called with the "
+          f"specified inputs. You specified {input_arity} inputs: {[i.name for i in inputs]}, but the loop "
+          f"condition needs {condition_arg_error}")
+    else:
+      raise TypeError(
+          f"Supplied loop condition function cannot be called with the "
+          f"specified inputs. You specified {input_arity} inputs: {[i.name for i in inputs]}, but the loop "
+          f"condition needs {condition_arg_error}. Note that infeed is not passed to the loop condition."
+      )
+
+  def condition_wrapper(*inputs):
+    # Discards the dummy output added for arity-0 loops.
+    if input_arity == 0:
+      inputs = []
+    return condition(*inputs)
+
+  def body_wrapper(*inputs):
+    """Wrapper around `body` that handles infeed queues and control deps."""
+    inputs = list(inputs)
+
+    # Discards the dummy output added for arity-0 loops.
+    if input_arity == 0:
+      inputs = []
+
+    # Runs `body` with the dequeue_ops appended.
+    if infeed_queue:
+      number_of_shards = tpu_function.get_tpu_context().number_of_shards
+      if number_of_shards is None:
+        raise ValueError("Can't build training loop with infeed when there is "
+                         "no tpu_shard_context. Are you building a loop or "
+                         "graph directly rather than from inside tpu.rewrite, "
+                         "tpu.batch_parallel, tpu.shard, or tpu.replicate?")
+      infeed_queue.set_number_of_shards(number_of_shards)
+      dequeue_ops = [d for d in infeed_queue.generate_dequeue_op()]
+    else:
+      dequeue_ops = []
+    outputs = body(*(inputs + dequeue_ops))
+
+    # If the computation only returned one value, make it a tuple.
+    if not isinstance(outputs, (list, tuple)):
+      outputs = (outputs,)
+
+    outputs = [
+        o if isinstance(o, ops.Operation) else ops.convert_to_tensor(o)
+        for o in outputs
+    ]
+
+    # Separates the returned Operations and Tensors.
+    output_operations = [o for o in outputs if isinstance(o, ops.Operation)]
+    output_tensors = [o for o in outputs
+                      if not isinstance(o, ops.Operation)]
+
+    if outputs != output_tensors + output_operations:
+      raise ValueError(
+          "TPU training loop body must return zero or more Tensor values "
+          "followed by zero or more Operations.")
+
+    output_types = [op.dtype for op in output_tensors]
+    if input_types != output_types:
+      raise TypeError(
+          "Mismatch between input types and output types for training loop "
+          "body: {} vs {}".format(input_types, output_types))
+
+    # Add the dequeue operations to output_operations to ensure they are run
+    # by the loop, even if the programmer's loop body does not use them.
+    output_operations += dequeue_ops
+
+    # Add a dummy output, if needed.
+    if not output_tensors:
+      output_tensors = array_ops.constant(0)
+
+    if output_operations:
+      # TODO(phawkins): in principle this is too restrictive since it serializes
+      # the training loop steps. In practice it does not matter since this loop
+      # will be compiled by XLA.
+      output_tensors = control_flow_ops.tuple(output_tensors,
+                                              control_inputs=output_operations)
+
+    if tensor_tracer.TensorTracer.is_enabled():
+      num_replicas = tpu_function.get_tpu_context().number_of_shards
+      if num_replicas is None:
+        num_replicas = 1
+      tt = tensor_tracer.TensorTracer()
+      output_tensors = tt.trace_tpu(ops.get_default_graph(),
+                                    output_tensors, None,
+                                    num_replicas)
+    return output_tensors
+
+  # If the body has arity 0, add a dummy loop-carried value to which we can add
+  # control dependencies from any side-effecting operations.
+  if input_arity == 0:
+    inputs = [array_ops.constant(0)]
+  return while_loop_tf.while_loop(
+      condition_wrapper, body_wrapper, inputs, name="", parallel_iterations=1)
+
+
+def repeat(
+    n: int,
+    body: Callable[..., Union[core_types.TensorLike, Iterable]],  # pylint:disable=g-bare-generic
+    inputs: Optional[List[core_types.TensorLike]] = None,
+    infeed_queue: Optional[tpu_feed.InfeedQueue] = None,
+    name: Any = None) -> List[core_types.TensorLike]:
+  """Builds a training loop that executes a fixed number of iterations.
+
+  The set of loop-carried tensors correspond to `inputs`.
+  `body` must be a function that takes and returns the values of the
+  loop-carried tensors.
+
+  Args:
+    n: the number of loop iterations
+    body: a Python function that builds the loop body.
+    inputs: a list of initial values passed into the training loop or None
+      (equivalent to an empty list).
+    infeed_queue: if not None, the infeed queue from which to append a tuple of
+      arguments as inputs to condition.
+    name: (Deprecated) Does nothing.
+
+  Returns:
+    The final values of the loop-carried tensors.
+  Raises:
+    ValueError: if there is a type error.
+  """
+  def _convert_to_list(xs):
+    if not isinstance(xs, (list, tuple)):
+      return [xs]
+    else:
+      return list(xs)
+
+  def cond(i, *args):
+    del args
+    return i < n
+
+  def body_wrapper(i, *args):
+    return [i + 1] + _convert_to_list(body(*args))
+
+  inputs = [0] if inputs is None else [0] + _convert_to_list(inputs)
+  outputs = while_loop(
+      cond, body_wrapper, inputs=inputs, infeed_queue=infeed_queue, name=name)
+  outputs = _convert_to_list(outputs)
+  if len(outputs) == 1:
+    # Returns the Op rather than an empty list.
+    return outputs[0].op
+  else:
+    return outputs[1:]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/tpu/util.py

@@ -0,0 +1,19 @@
+# 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.
+# ==============================================================================
+"""Stub file to maintain backwards compatibility."""
+
+# pylint: disable=wildcard-import,unused-import
+from tensorflow_estimator.python.estimator.tpu.util import *
+# pylint: enable=wildcard-import,unused-import

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/asset.py

@@ -0,0 +1,116 @@
+# 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.
+# ==============================================================================
+"""Asset-type Trackable object."""
+import os
+
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_conversion_registry
+from tensorflow.python.lib.io import file_io
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.saved_model import path_helpers
+from tensorflow.python.trackable import base
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("saved_model.Asset")
+class Asset(base.Trackable):
+  """Represents a file asset to hermetically include in a SavedModel.
+
+  A SavedModel can include arbitrary files, called assets, that are needed
+  for its use. For example a vocabulary file used initialize a lookup table.
+
+  When a trackable object is exported via `tf.saved_model.save()`, all the
+  `Asset`s reachable from it are copied into the SavedModel assets directory.
+  Upon loading, the assets and the serialized functions that depend on them
+  will refer to the correct filepaths inside the SavedModel directory.
+
+  Example:
+
+  ```
+  filename = tf.saved_model.Asset("file.txt")
+
+  @tf.function(input_signature=[])
+  def func():
+    return tf.io.read_file(filename)
+
+  trackable_obj = tf.train.Checkpoint()
+  trackable_obj.func = func
+  trackable_obj.filename = filename
+  tf.saved_model.save(trackable_obj, "/tmp/saved_model")
+
+  # The created SavedModel is hermetic, it does not depend on
+  # the original file and can be moved to another path.
+  tf.io.gfile.remove("file.txt")
+  tf.io.gfile.rename("/tmp/saved_model", "/tmp/new_location")
+
+  reloaded_obj = tf.saved_model.load("/tmp/new_location")
+  print(reloaded_obj.func())
+  ```
+
+  Attributes:
+    asset_path: A path, or a 0-D `tf.string` tensor with path to the asset.
+  """
+
+  def __init__(self, path):
+    """Record the full path to the asset."""
+    if isinstance(path, os.PathLike):
+      path = os.fspath(path)
+    # The init_scope prevents functions from capturing `path` in an
+    # initialization graph, since it is transient and should not end up in a
+    # serialized function body.
+    with ops.init_scope(), ops.device("CPU"):
+      self._path = ops.convert_to_tensor(
+          path, dtype=dtypes.string, name="asset_path")
+
+  @property
+  def asset_path(self):
+    """Fetch the current asset path."""
+    return self._path
+
+  @classmethod
+  def _deserialize_from_proto(cls, object_proto, export_dir, asset_file_def,
+                              **unused_kwargs):
+    proto = object_proto.asset
+    filename = file_io.join(
+        path_helpers.get_assets_dir(export_dir),
+        asset_file_def[proto.asset_file_def_index].filename)
+    asset = cls(filename)
+    if not context.executing_eagerly():
+      ops.add_to_collection(ops.GraphKeys.ASSET_FILEPATHS, asset.asset_path)
+    return asset
+
+  def _add_trackable_child(self, name, value):
+    setattr(self, name, value)
+
+  def _export_to_saved_model_graph(self, tensor_map, **unused_kwargs):
+    # TODO(b/205008097): Instead of mapping 1-1 between trackable asset
+    # and asset in the graph def consider deduping the assets that
+    # point to the same file.
+    asset_path_initializer = array_ops.placeholder(
+        shape=self.asset_path.shape,
+        dtype=dtypes.string,
+        name="asset_path_initializer")
+    asset_variable = resource_variable_ops.ResourceVariable(
+        asset_path_initializer)
+
+    tensor_map[self.asset_path] = asset_variable
+    return [self.asset_path]
+
+
+tensor_conversion_registry.register_tensor_conversion_function(
+    Asset, lambda asset, **kw: ops.convert_to_tensor(asset.asset_path, **kw))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/autotrackable.py

@@ -0,0 +1,152 @@
+# 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.
+# ==============================================================================
+"""Dependency tracking for trackable objects."""
+
+import warnings
+
+from absl import logging
+
+from tensorflow.python.eager import def_function
+from tensorflow.python.eager import function as defun
+from tensorflow.python.trackable import base
+from tensorflow.python.trackable import data_structures
+from tensorflow.python.types import core as core_types
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("__internal__.tracking.AutoTrackable", v1=[])
+class AutoTrackable(base.Trackable):
+  """Manages dependencies on other objects.
+
+  `Trackable` objects may have dependencies: other `Trackable` objects
+  which should be saved if the object declaring the dependency is saved. A
+  correctly saveable program has a dependency graph such that if changing a
+  global variable affects an object (e.g. changes the behavior of any of its
+  methods) then there is a chain of dependencies from the influenced object to
+  the variable.
+
+  Dependency edges have names, and are created implicitly when a
+  `Trackable` object is assigned to an attribute of another
+  `Trackable` object. For example:
+
+  ```
+  obj = Trackable()
+  obj.v = ResourceVariable(0.)
+  ```
+
+  The `Trackable` object `obj` now has a dependency named "v" on a
+  variable.
+
+  `Trackable` objects may specify `Tensor`s to be saved and restored
+  directly (e.g. a `Variable` indicating how to save itself) rather than through
+  dependencies on other objects. See
+  `Trackable._gather_saveables_for_checkpoint` for details.
+  """
+
+  def __setattr__(self, name, value):
+    """Support self.foo = trackable syntax."""
+    try:
+      if getattr(self, name) is value:
+        # Short circuit for `self.$x = self.$x`.
+        return
+    except AttributeError:
+      pass
+
+    if getattr(self, "_self_setattr_tracking", True):
+      value = data_structures.sticky_attribute_assignment(
+          trackable=self, value=value, name=name)
+    super(AutoTrackable, self).__setattr__(name, value)
+
+  def __delattr__(self, name):
+    self._delete_tracking(name)
+    super(AutoTrackable, self).__delattr__(name)
+
+  def _no_dependency(self, value):
+    """Override to allow TrackableBase to disable dependency tracking."""
+    return data_structures.NoDependency(value)
+
+  def _trackable_children(self, save_type=base.SaveType.CHECKPOINT, **kwargs):
+    """Returns all children of a trackable, including functions."""
+    if save_type != base.SaveType.SAVEDMODEL:
+      return super(AutoTrackable, self)._trackable_children(
+          save_type, **kwargs)
+
+    functions = {}
+    try:
+      # We get the attributes, suppressing warnings and exceptions.
+      logging_verbosity = logging.get_verbosity()
+      logging.set_verbosity(logging.FATAL)
+      for attribute_name in dir(self):
+        try:
+          with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            attribute_value = getattr(self, attribute_name, None)
+        except Exception:  # pylint: disable=broad-except
+          # NOTE: If we make the exception catching here less broad, we might
+          # need to revisit `finally` block below.
+          # We really don't want to throw an exception just because some
+          # object's attribute accessor is broken.
+          attribute_value = None
+        if isinstance(attribute_value, (def_function.Function,
+                                        defun.ConcreteFunction)):
+          functions[attribute_name] = attribute_value
+    finally:
+      logging.set_verbosity(logging_verbosity)
+
+    # Trace concrete functions to force side-effects:
+    #   1. populate the cache for functions that have an input_signature
+    #      and have not been called
+    #   2. force side effects of creation of concrete functions, e.g. create
+    #      variables on first run.
+    for fn in functions.values():
+      if isinstance(fn, def_function.Function):
+        fn._list_all_concrete_functions_for_serialization()  # pylint: disable=protected-access
+
+    # Additional dependencies may have been generated during function tracing
+    # (e.g. captured variables). Make sure we return those too.
+    children = {}
+    for name, child in self._checkpoint_dependencies:
+      if isinstance(child, (core_types.PolymorphicFunction,
+                            core_types.ConcreteFunction)):
+        # Skip "tracked" functions for now since there may be objects that
+        # automatically track functions that should not be saved.
+        # TODO(kathywu): remove once `_list_functions_for_serialization` has
+        # been fully deprecated.
+        continue
+
+      if name in functions and child is not functions[name]:
+        raise ValueError(
+            "Can't save object because it has multiple children with the same "
+            f"name. Object: {self}, attribute name: {name}, child 1: "
+            f"{child}, child 2: {functions[name]}")
+
+      children[name] = child
+
+    children.update(functions)
+    return children
+
+  def _delete_tracking(self, name):
+    """Removes the tracking of name."""
+    self._maybe_initialize_trackable()
+    if name in self._unconditional_dependency_names:
+      del self._unconditional_dependency_names[name]
+      for index, (dep_name, _) in enumerate(
+          self._unconditional_checkpoint_dependencies):
+        if dep_name == name:
+          del self._unconditional_checkpoint_dependencies[index]
+          break
+
+  def _add_trackable_child(self, name, value):
+    self.__setattr__(name, value)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/base.py

@@ -0,0 +1,1077 @@
+"""An object-local variable management scheme."""
+# 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.
+# ==============================================================================
+import collections
+import weakref
+
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import gen_control_flow_ops
+from tensorflow.python.trackable import constants
+from tensorflow.python.training.saving import saveable_object
+from tensorflow.python.util import tf_contextlib
+from tensorflow.python.util import tf_decorator
+from tensorflow.python.util.tf_export import tf_export
+
+OBJECT_GRAPH_PROTO_KEY = constants.OBJECT_GRAPH_PROTO_KEY
+VARIABLE_VALUE_KEY = constants.VARIABLE_VALUE_KEY
+OBJECT_CONFIG_JSON_KEY = constants.OBJECT_CONFIG_JSON_KEY
+SaveType = constants.SaveType
+
+
+@tf_export("__internal__.tracking.TrackableReference", v1=[])
+class TrackableReference(object):
+  """A named reference to a trackable object for use with the `Trackable` class.
+
+  These references mark named `Trackable` dependencies of a `Trackable` object
+  and should be created when overriding `Trackable._checkpoint_dependencies`.
+
+  Attributes:
+    name: The local name for this dependency.
+    ref: The `Trackable` object being referenced.
+  """
+
+  __slots__ = ("_name", "_ref")
+
+  def __init__(self, name, ref):
+    self._name = name
+    self._ref = ref
+
+  @property
+  def name(self):
+    return self._name
+
+  @property
+  def ref(self):
+    return self._ref
+
+  def __iter__(self):
+    yield self.name
+    yield self.ref
+
+  def __repr__(self):
+    return f"{self.__class__.__name__}(name={self.name}, ref={self.ref})"
+
+  def __eq__(self, o):
+    if isinstance(o, tuple):
+      return (self.name, self.ref) == o
+    elif isinstance(o, TrackableReference):
+      return self.name == o.name and self.ref == o.ref
+    else:
+      return False
+
+
+class WeakTrackableReference(TrackableReference):
+  """TrackableReference that stores weak references."""
+  __slots__ = ()
+
+  def __init__(self, name, ref):
+    if not isinstance(self, weakref.ref):
+      ref = weakref.ref(ref)
+    super(WeakTrackableReference, self).__init__(name=name, ref=ref)
+
+  @property
+  def ref(self):
+    return self._ref()
+
+
+# TODO(bfontain):  Update once sharded initialization interface is finalized.
+ShardInfo = collections.namedtuple("CheckpointInitialValueShardInfo",
+                                   ["shape", "offset"])
+
+
+@tf_export("__internal__.tracking.CheckpointInitialValueCallable", v1=[])
+class CheckpointInitialValueCallable(object):
+  """A callable object that returns a CheckpointInitialValue.
+
+  See CheckpointInitialValue for more information.
+  """
+
+  def __init__(self, checkpoint_position):
+    self._checkpoint_position = checkpoint_position
+
+  @property
+  def checkpoint_position(self):
+    return self._checkpoint_position
+
+  def __call__(self, shape=None, dtype=None, shard_info=None):
+    # Note that the signature here is for compatibility with normal callable
+    # initializers which take shape and dtype. Although dtype isn't used, it
+    # will get passed in by a functool.partial_wrapper in places like
+    # base_layer_utils.py's make_variable.
+    return CheckpointInitialValue(
+        self._checkpoint_position, shape, shard_info=shard_info)
+
+  @property
+  def restore_uid(self):
+    return self._checkpoint_position.restore_uid
+
+
+@tf_export("__internal__.tracking.CheckpointInitialValue", v1=[])
+class CheckpointInitialValue(object):
+  """Tensor wrapper for managing update UIDs in `Variables`.
+
+  When supplied as an initial value, objects of this type let a `Variable`
+  (`Variable`, `ResourceVariable`, etc.) know the UID of the restore the initial
+  value came from. This allows deferred restorations to be sequenced in the
+  order the user specified them, and lets us fall back on assignment if an
+  initial value is not set (e.g. due to a custom getter interfering).
+
+  See comments in _add_variable_with_custom_getter for more information about
+  how `CheckpointInitialValue` is used.
+  """
+
+  def __init__(self, checkpoint_position, shape=None, shard_info=None):
+    if shard_info:
+      full_shape_str = " ".join("%d" % d for d in shape) + " "
+      slice_spec = ":".join(
+          "%d,%d" % (o, s) for o, s in zip(shard_info.offset, shard_info.shape))
+      shape_and_slice = full_shape_str + slice_spec
+    else:
+      shape_and_slice = ""
+    self.wrapped_value = checkpoint_position.value_tensors(
+        {VARIABLE_VALUE_KEY: shape_and_slice})[VARIABLE_VALUE_KEY]
+    self._checkpoint_position = checkpoint_position
+
+  def __tf_tensor__(self, dtype=None, name=None):
+    del dtype
+    del name
+    return self.wrapped_value
+
+  @property
+  def checkpoint_position(self):
+    return self._checkpoint_position
+
+
+class NoRestoreSaveable(saveable_object.SaveableObject):
+  """Embeds a tensor in a checkpoint with no restore ops."""
+
+  def __init__(self, tensor, name, dtype=None, device=None):
+    spec = saveable_object.SaveSpec(
+        tensor, "", name, dtype=dtype, device=device)
+    super(NoRestoreSaveable, self).__init__(tensor, [spec], name)
+
+  def restore(self, restored_tensors, restored_shapes):
+    return gen_control_flow_ops.no_op()
+
+
+_SlotVariableRestoration = collections.namedtuple(
+    "_SlotVariableRestoration",
+    [
+        # The checkpoint proto id of the optimizer object.
+        "optimizer_id",
+        # The checkpoint proto id of the slot variable.
+        "slot_variable_id",
+        "slot_name",
+    ])
+
+
+@tf_export("__internal__.tracking.no_automatic_dependency_tracking", v1=[])
+def no_automatic_dependency_tracking(method):
+  """Disables automatic dependency tracking on attribute assignment.
+
+  Use to decorate any method of a Trackable object. Attribute assignment in
+  that method will not add dependencies (also respected in Model). Harmless if
+  used in a class which does not do automatic dependency tracking (which means
+  it's safe to use in base classes which may have subclasses which also inherit
+  from Trackable).
+
+  Args:
+    method: The method to decorate.
+
+  Returns:
+    A decorated method which sets and un-sets automatic dependency tracking for
+    the object the method is called on (not thread safe).
+  """
+
+  def _method_wrapper(self, *args, **kwargs):
+    previous_value = getattr(self, "_self_setattr_tracking", True)
+    self._self_setattr_tracking = False  # pylint: disable=protected-access
+    try:
+      result = method(self, *args, **kwargs)
+    finally:
+      self._self_setattr_tracking = previous_value  # pylint: disable=protected-access
+    return result
+
+  return tf_decorator.make_decorator(
+      target=method, decorator_func=_method_wrapper)
+
+
+@tf_contextlib.contextmanager
+def no_manual_dependency_tracking_scope(obj):
+  """A context that disables manual dependency tracking for the given `obj`.
+
+  Sometimes library methods might track objects on their own and we might want
+  to disable that and do the tracking on our own. One can then use this context
+  manager to disable the tracking the library method does and do your own
+  tracking.
+
+  For example:
+
+  class TestLayer(tf.keras.Layer):
+    def build():
+      with no_manual_dependency_tracking_scope(self):
+        var = self.add_variable("name1")  # Creates a var and doesn't track it
+      self._track_trackable("name2", var)  # We track variable with name `name2`
+
+  Args:
+    obj: A trackable object.
+
+  Yields:
+    a scope in which the object doesn't track dependencies manually.
+  """
+  # pylint: disable=protected-access
+  previous_value = getattr(obj, "_manual_tracking", True)
+  obj._manual_tracking = False
+  try:
+    yield
+  finally:
+    obj._manual_tracking = previous_value
+
+
+@tf_contextlib.contextmanager
+def no_automatic_dependency_tracking_scope(obj):
+  """A context that disables automatic dependency tracking when assigning attrs.
+
+  Objects that inherit from Autotrackable automatically creates dependencies
+  to trackable objects through attribute assignments, and wraps data structures
+  (lists or dicts) with trackable classes. This scope may be used to temporarily
+  disable this behavior. This works similar to the decorator
+  `no_automatic_dependency_tracking`.
+
+  Example usage:
+  ```
+  model = tf.keras.Model()
+  model.arr1 = []  # Creates a ListWrapper object
+  with no_automatic_dependency_tracking_scope(model):
+    model.arr2 = []  # Creates a regular, untracked python list
+  ```
+
+  Args:
+    obj: A trackable object.
+
+  Yields:
+    a scope in which the object doesn't track dependencies.
+  """
+  previous_value = getattr(obj, "_setattr_tracking", True)
+  obj._setattr_tracking = False  # pylint: disable=protected-access
+  try:
+    yield
+  finally:
+    obj._setattr_tracking = previous_value  # pylint: disable=protected-access
+
+
+@tf_export("__internal__.tracking.Trackable", v1=[])
+class Trackable(object):
+  """Base class for `Trackable` objects without automatic dependencies.
+
+  This class has no __setattr__ override for performance reasons. Dependencies
+  must be added explicitly. Unless attribute assignment is performance-critical,
+  use `AutoTrackable` instead. Use `Trackable` for `isinstance`
+  checks.
+  """
+
+  # For compatibility with wrapt.ObjectProxy, attributes are all prefixed with
+  # _self_. We have some properties to forward semi-public attributes to their
+  # _self_ equivalents.
+
+  @property
+  def _setattr_tracking(self):
+    if not hasattr(self, "_self_setattr_tracking"):
+      self._self_setattr_tracking = True
+    return self._self_setattr_tracking
+
+  @_setattr_tracking.setter
+  def _setattr_tracking(self, value):
+    self._self_setattr_tracking = value
+
+  @property
+  def _update_uid(self):
+    return self._self_update_uid
+
+  @_update_uid.setter
+  def _update_uid(self, value):
+    self._self_update_uid = value
+
+  @property
+  def _unconditional_checkpoint_dependencies(self):
+    return self._self_unconditional_checkpoint_dependencies
+
+  @property
+  def _unconditional_dependency_names(self):
+    return self._self_unconditional_dependency_names
+
+  @property
+  def _name_based_restores(self):
+    return self._self_name_based_restores
+
+  # Trackable does not do automatic dependency tracking, but uses the
+  # no_automatic_dependency_tracking decorator so it can avoid adding
+  # dependencies if a subclass is Trackable / inherits from Model (both of
+  # which have __setattr__ overrides).
+  @no_automatic_dependency_tracking
+  def _maybe_initialize_trackable(self):
+    """Initialize dependency management.
+
+    Not __init__, since most objects will forget to call it.
+    """
+    if hasattr(self, "_self_unconditional_checkpoint_dependencies"):
+      # __init__ already called. This check means that we don't need
+      # Trackable.__init__() in the constructor of every TensorFlow object.
+      return
+    # A list of TrackableReference objects. Some classes implementing
+    # `Trackable`, notably `Optimizer`s, may override the
+    # _checkpoint_dependencies property with conditional dependencies
+    # (e.g. based on the current graph when saving).
+    self._self_unconditional_checkpoint_dependencies = []
+    # Maps names -> Trackable objects
+    self._self_unconditional_dependency_names = {}
+    # Restorations for other Trackable objects on which this object may
+    # eventually depend. Maps local name -> CheckpointPosition list. Optimizers
+    # tack on conditional dependencies, and so need separate management of
+    # deferred dependencies too.
+    self._self_unconditional_deferred_dependencies = {}
+    # The UID of the highest assignment to this object. Used to ensure that the
+    # last requested assignment determines the final value of an object.
+    if hasattr(self, "_self_update_uid"):
+      raise AssertionError(
+          "Internal error: the object had an update UID set before its "
+          "initialization code was run.")
+    self._self_update_uid = -1
+    # When executing eagerly, holds a collection of _NameBasedRestoreCoordinator
+    # instances, which should be checked when creating variables or other
+    # saveables. These are passed on recursively to all dependencies, since
+    # unlike object-based checkpoint restores we don't know which subgraph is
+    # being restored in advance. This mechanism is only necessary for
+    # restore-on-create when executing eagerly, and so is unused when graph
+    # building.
+    self._self_name_based_restores = set()
+
+    # Dictionary of SaveableObjects factories. This dictionary is defined when
+    # the object is loaded from the SavedModel. When writing a custom class,
+    # prefer overriding "_gather_saveables_from_checkpoint" to using this
+    # attribute.
+    self._self_saveable_object_factories = {}
+
+  @property
+  def _object_identifier(self):
+    """String used to identify this object in a SavedModel.
+
+    THIS FIELD HAS BEEN DEPRECATED IN FAVOR OF THE NAME REGISTERED WITH
+    `register_serializable`.
+
+    Generally, the object identifier is constant across objects of the same
+    class, while the metadata field is used for instance-specific data.
+
+    Returns:
+      String object identifier.
+    """
+    return "_generic_user_object"
+
+  def _no_dependency(self, value):
+    """If automatic dependency tracking is enabled, ignores `value`."""
+    return value
+
+  def _name_based_attribute_restore(self, checkpoint):
+    """Restore the object's attributes from a name-based checkpoint."""
+    self._self_name_based_restores.add(checkpoint)
+    if self._self_update_uid < checkpoint.restore_uid:
+      checkpoint.eager_restore(self)
+      self._self_update_uid = checkpoint.restore_uid
+
+  @property
+  def _checkpoint_dependencies(self):
+    """All dependencies of this object.
+
+    May be overridden to include conditional dependencies.
+
+    Returns:
+      A list of `TrackableReference` objects indicating named
+      `Trackable` dependencies which should be saved along with this
+      object.
+    """
+    return self._self_unconditional_checkpoint_dependencies
+
+  @property
+  def _deferred_dependencies(self):
+    """A dictionary with deferred dependencies.
+
+    Stores restorations for other Trackable objects on which this object
+    may eventually depend. May be overridden by sub-classes (e.g. Optimizers use
+    conditional dependencies based the current graph, and so need separate
+    management of deferred dependencies too).
+
+    Returns:
+      A dictionary mapping from local name to a list of CheckpointPosition
+      objects.
+    """
+    return self._self_unconditional_deferred_dependencies
+
+  def _lookup_dependency(self, name, cached_dependencies=None):
+    """Look up a dependency by name.
+
+    May be overridden to include conditional dependencies.
+
+    Args:
+      name: The local name of the dependency.
+      cached_dependencies: Optional dict containing all computed dependencies
+        returned by `self._trackable_children()`.
+
+    Returns:
+      A `Trackable` object, or `None` if no dependency by this name was
+      found.
+    """
+    if cached_dependencies:
+      return cached_dependencies.get(name)
+    return self._self_unconditional_dependency_names.get(name)
+
+  def _add_variable_with_custom_getter(self,
+                                       name,
+                                       shape=None,
+                                       dtype=dtypes.float32,
+                                       initializer=None,
+                                       getter=None,
+                                       overwrite=False,
+                                       **kwargs_for_getter):
+    """Restore-on-create for a variable be saved with this `Trackable`.
+
+    If the user has requested that this object or another `Trackable` which
+    depends on this object be restored from a checkpoint (deferred loading
+    before variable object creation), `initializer` may be ignored and the value
+    from the checkpoint used instead.
+
+    Args:
+      name: A name for the variable. Must be unique within this object.
+      shape: The shape of the variable.
+      dtype: The data type of the variable.
+      initializer: The initializer to use. Ignored if there is a deferred
+        restoration stored in the Trackable.
+      getter: The getter to wrap which actually fetches the variable.
+      overwrite: If True, disables unique name and type checks.
+      **kwargs_for_getter: Passed to the getter.
+
+    Returns:
+      The new variable object.
+
+    Raises:
+      ValueError: If the variable name is not unique.
+    """
+    self._maybe_initialize_trackable()
+    with ops.init_scope():
+      if context.executing_eagerly():
+        # If this is a variable with a single Tensor stored in the checkpoint,
+        # we can set that value as an initializer rather than initializing and
+        # then assigning (when executing eagerly). This call returns None if
+        # there is nothing to restore.
+        checkpoint_initializer = self._preload_simple_restoration(name=name)
+      else:
+        checkpoint_initializer = None
+      if (checkpoint_initializer is not None and
+          not (isinstance(initializer, CheckpointInitialValueCallable) and
+               (initializer.restore_uid > checkpoint_initializer.restore_uid))):
+        # If multiple Trackable objects are "creating" the same variable
+        # via the magic of custom getters, the one with the highest restore UID
+        # (the one called last) has to make the final initializer. If another
+        # custom getter interrupts this process by overwriting the initializer,
+        # then we'll catch that when we call _track_trackable. So this is
+        # "best effort" to set the initializer with the highest restore UID.
+        initializer = checkpoint_initializer
+    new_variable = getter(
+        name=name,
+        shape=shape,
+        dtype=dtype,
+        initializer=initializer,
+        **kwargs_for_getter)
+
+    # If we set an initializer and the variable processed it, tracking will not
+    # assign again. It will add this variable to our dependencies, and if there
+    # is a non-trivial restoration queued, it will handle that. This also
+    # handles slot variables.
+    if not overwrite or isinstance(new_variable, Trackable):
+      return self._track_trackable(new_variable, name=name, overwrite=overwrite)
+    else:
+      # TODO(allenl): Some variable types are not yet supported. Remove this
+      # fallback once all get_variable() return types are Trackable.
+      return new_variable
+
+  def _preload_simple_restoration(self, name):
+    """Return a dependency's value for restore-on-create.
+
+    Note the restoration is not deleted; if for some reason preload is called
+    and then not assigned to the variable (for example because a custom getter
+    overrides the initializer), the assignment will still happen once the
+    variable is tracked (determined based on checkpoint.restore_uid).
+
+    Args:
+      name: The object-local name of the dependency holding the variable's
+        value.
+
+    Returns:
+      An callable for use as a variable's initializer/initial_value, or None if
+      one should not be set (either because there was no variable with this name
+      in the checkpoint or because it needs more complex deserialization). Any
+      non-trivial deserialization will happen when the variable object is
+      tracked.
+    """
+    deferred_dependencies_list = self._deferred_dependencies.get(name, ())
+    if not deferred_dependencies_list:
+      # Nothing to do; we don't have a restore for this dependency queued up.
+      return
+    for checkpoint_position in deferred_dependencies_list:
+      if not checkpoint_position.is_simple_variable():
+        # If _any_ pending restoration is too complicated to fit in an
+        # initializer (because it has dependencies, or because there are
+        # multiple Tensors to restore), bail and let the general tracking code
+        # handle it.
+        return None
+    checkpoint_position = max(
+        deferred_dependencies_list,
+        key=lambda restore: restore.checkpoint.restore_uid)
+    return CheckpointInitialValueCallable(
+        checkpoint_position=checkpoint_position)
+
+  def _track_trackable(self, trackable, name, overwrite=False):
+    """Declare a dependency on another `Trackable` object.
+
+    Indicates that checkpoints for this object should include variables from
+    `trackable`.
+
+    Variables in a checkpoint are mapped to `Trackable`s based on the names
+    provided when the checkpoint was written. To avoid breaking existing
+    checkpoints when modifying a class, neither variable names nor dependency
+    names (the names passed to `_track_trackable`) may change.
+
+    Args:
+      trackable: A `Trackable` which this object depends on.
+      name: A local name for `trackable`, used for loading checkpoints into the
+        correct objects.
+      overwrite: Boolean, whether silently replacing dependencies is OK. Used
+        for __setattr__, where throwing an error on attribute reassignment would
+        be inappropriate.
+
+    Returns:
+      `trackable`, for convenience when declaring a dependency and
+      assigning to a member variable in one statement.
+
+    Raises:
+      TypeError: If `trackable` does not inherit from `Trackable`.
+      ValueError: If another object is already tracked by this name.
+    """
+    self._maybe_initialize_trackable()
+    if not isinstance(trackable, Trackable):
+      raise TypeError(
+          "Trackable._track_trackable() can only be used to track objects of "
+          f"type Trackable. Got type {type(trackable)}.")
+    if not getattr(self, "_manual_tracking", True):
+      return trackable
+    new_reference = TrackableReference(name=name, ref=trackable)
+    current_object = self._lookup_dependency(name)
+    if (current_object is not None and current_object is not trackable):
+      if not overwrite:
+        raise ValueError(
+            f"Called Trackable._track_trackable() with name='{name}', "
+            "but a Trackable with this name is already declared as a "
+            "dependency. Names must be unique (or overwrite=True).")
+      # This is a weird thing to do, but we're not going to stop people from
+      # using __setattr__.
+      for index, (old_name, _) in enumerate(
+          self._self_unconditional_checkpoint_dependencies):
+        if name == old_name:
+          self._self_unconditional_checkpoint_dependencies[
+              index] = new_reference
+    elif current_object is None:
+      self._self_unconditional_checkpoint_dependencies.append(new_reference)
+      self._handle_deferred_dependencies(name=name, trackable=trackable)
+    self._self_unconditional_dependency_names[name] = trackable
+    return trackable
+
+  def _handle_deferred_dependencies(self, name, trackable):
+    """Pop and load any deferred checkpoint restores into `trackable`.
+
+    This method does not add a new dependency on `trackable`, but it does
+    check if any outstanding/deferred dependencies have been queued waiting for
+    this dependency to be added (matched based on `name`). If so,
+    `trackable` and its dependencies are restored. The restorations are
+    considered fulfilled and so are deleted.
+
+    `_track_trackable` is more appropriate for adding a
+    normal/unconditional dependency, and includes handling for deferred
+    restorations. This method allows objects such as `Optimizer` to use the same
+    restoration logic while managing conditional dependencies themselves, by
+    overriding `_checkpoint_dependencies` and `_lookup_dependency` to change the
+    object's dependencies based on the context it is saved/restored in (a single
+    optimizer instance can have state associated with multiple graphs).
+
+    Args:
+      name: The name of the dependency within this object (`self`), used to
+        match `trackable` with values saved in a checkpoint.
+      trackable: The Trackable object to restore (inheriting from `Trackable`).
+    """
+    self._maybe_initialize_trackable()
+    trackable._maybe_initialize_trackable()  # pylint: disable=protected-access
+    deferred_dependencies_list = self._deferred_dependencies.pop(name, ())
+    for checkpoint_position in sorted(
+        deferred_dependencies_list,
+        key=lambda restore: restore.checkpoint.restore_uid,
+        reverse=True):
+      checkpoint_position.restore(trackable)
+
+    # Pass on any name-based restores queued in this object.
+    for name_based_restore in sorted(
+        self._self_name_based_restores,
+        key=lambda checkpoint: checkpoint.restore_uid,
+        reverse=True):
+      trackable._name_based_attribute_restore(name_based_restore)  # pylint: disable=protected-access
+
+  def _gather_saveables_for_checkpoint(self):
+    """Returns a dictionary of values to checkpoint with this object.
+
+    NOTE: This method is deprecated, prefer implementing `_serialize_to_tensors`
+    and `_restore_from_tensors` instead. This method is only used in the
+    deprecated `tf.compat.v1.train.Saver`.
+
+    Keys in the returned dictionary are local to this object and in a separate
+    namespace from dependencies. Values may either be `SaveableObject` factories
+    or variables easily converted to `SaveableObject`s (as in
+    `tf.compat.v1.train.Saver`'s
+    `var_list` constructor argument).
+
+    `SaveableObjects` have a name set, which Trackable needs to generate
+    itself. So rather than returning `SaveableObjects` directly, this method
+    should return a dictionary of callables which take `name` arguments and
+    return `SaveableObjects` with that name.
+
+    If this object may also be passed to the global-name-based
+    `tf.compat.v1.train.Saver`,
+    the returned callables should have a default value for their name argument
+    (i.e. be callable with no arguments).
+
+    Returned values must be saved only by this object; if any value may be
+    shared, it should instead be a dependency. For example, variable objects
+    save their own values with the key `VARIABLE_VALUE_KEY`, but objects which
+    reference variables simply add a dependency.
+
+    **AsyncCheckpoint Support**
+    If your Trackable implements `_gather_saveables_for_checkpoint`,
+    `_copy_trackable_to_cpu` needs to be implemented as well to support
+    asynchronous checkpoint.
+
+    Returns:
+      The dictionary mapping attribute names to `SaveableObject` factories
+      described above. For example:
+      {VARIABLE_VALUE_KEY:
+       lambda name="global_name_for_this_object":
+       SaveableObject(name=name, ...)}
+    """
+    return getattr(self, "_self_saveable_object_factories", {})
+
+  def _serialize_to_tensors(self):
+    """Gathers tensors to save to the checkpoint.
+
+    You should only override `_serialize_to_tensors` and `_restore_from_tensors`
+    if you are defining a custom resource or variable with custom ops.
+
+    Otherwise, please store the state of your trackable in `tf.Variable` objects
+    and add them to Trackable object hierarchy using `setattr` (for subclasses
+    of `AutoTrackable`) or overriding the `_trackable_children` method.
+
+    For an example of a valid implementation of these two methods, please see
+    `DenseHashTable`.
+
+    **Invalid implementation**
+
+    ````
+    class NamedTrackable(Trackable):
+      def __init__(self, name: str):
+        self.name = name
+      def _serialize_to_tensors(self):
+        return {"name": self.name}
+      def _restore_from_tensors(self, restored_tensors):
+        self.name = restored_tensors["name"]
+    ```
+
+    In this example, `NamedTrackable` can be saved and restored from
+    checkpoints, but is incompatible with SavedModel, which tries to convert
+    the serialize/restore functions into tf.functions. This fails because
+    attribute assignment (`self.attr = new_value`) is not graph-friendly.
+
+    **Suggested fix**
+
+    ```
+    class NamedTrackable(Trackable):
+      def __init__(self, name: str):
+        self.name = tf.Variable(name)
+
+      def _trackable_children(self):
+        return {"name": self.name}
+    ```
+
+    If the `name` attribute should be saved to the checkpoint, then convert it
+    a `tf.Variable`.
+
+    **TF1 Saver Compatibility**
+    If your Trackable needs to be comatible with `tf.compat.v1.train.Saver`,
+    implement `_gather_saveables_from_checkpoint`.
+
+    **AsyncCheckpoint Support**
+    If your Trackable implements `_serialize_to_tensors`,
+    `_copy_trackable_to_cpu` needs to be implemented as well to support
+    asynchronous checkpoint.
+
+    Returns:
+      A dictionary mapping names to tensors.
+    """
+    raise NotImplementedError
+
+  def _restore_from_tensors(self, restored_tensors):
+    """Restores checkpointed values to this `Trackable`.
+
+    Please see the documentation for `Trackable._serialize_to_tensors`.
+
+    Args:
+      restored_tensors: A dictionary mapping names to tensors. The keys to this
+        dictionary matches the names passed to _serialize_to_tensors.
+
+    Returns:
+      An op that runs the restoration.
+    """
+    raise NotImplementedError
+
+  def _serialize_to_proto(self, object_proto=None, **kwargs):
+    """Returns a proto of any type to be saved into the SavedModel.
+
+    Trackable classes decorated with `register_serializable` should overwrite
+    this method to save metadata for this object to the SavedModel. The proto
+    returned by this function will be passed to `_deserialize_from_proto` in the
+    form of a `google.protobuf.Any` proto.
+
+    This data is only saved and used by the Python API. Existing C++ loading
+    APIs such as `tensorflow::LoadSavedModel` will not read this field at all.
+
+    Args:
+      object_proto: A `SavedObject` proto that may be filled by this function.
+        Only the core serializable types (Variable, Function, Constant, Asset)
+        should modify this argument.
+      **kwargs: Future keyword arguments passed to the object during saving.
+
+    Returns:
+      A proto that serializes this class's type.
+    """
+    del object_proto, kwargs  # Unused.
+
+    return None
+
+  @classmethod
+  def _deserialize_from_proto(cls,
+                              proto=None,
+                              dependencies=None,
+                              object_proto=None,
+                              export_dir=None,
+                              asset_file_def=None,
+                              operation_attributes=None,
+                              **kwargs):
+    """Returns a new object restored by the SavedModel.
+
+    Trackable classes decorated with `register_serializable` should overwrite
+    this method to change how the object is loaded from SavedModel. By default,
+    the object is initialized with no arguments.
+
+    Example:
+
+    ```
+    def _serialize_to_proto(self, **unused_kwargs):
+      return Message(name="a")
+
+    @classmethod
+    def _deserialize_from_proto(cls, proto, **unused_kwargs):
+      if proto.Is(Message.DESCRIPTOR):
+        unpacked = Message()
+        proto.Unpack(unpacked)
+        return cls(unpacked.name)
+      else:
+        return cls()
+    ```
+
+    This function is only used by the Python API. C++ and TensorFlow Serving do
+    not have access to your registered class and cannot execute any of the
+    non-tf.functions attached to the Python class. However, all signatures and
+    tf.functions are still accessible.
+
+    **Avoid creating duplicate trackables**
+
+    SavedModel is saved by recursively gathering all of the trackables and their
+    children. SavedModel loading reverses those steps by creating all
+    trackables, then reconnecting the children trackables to their parents using
+    `Trackable._add_trackable_child`.
+
+    That means that if `_deserialize_from_proto` calls the `__init__` function,
+    which creates all of the children trackables, then those children end up
+    being created *twice*.
+
+    To avoid this, structure your code so that Trackables are not created
+    when deserialized from SavedModel:
+
+    ```
+    @register_serializable()
+    class Serializable(trackable):
+      def __init __(self, from_proto=False):
+        create_non_trackable_objects()
+        if not from_proto:
+          create_variables_and_other_trackables()
+
+      def _deserialize_from_proto(cls, **kwargs):
+        return cls(from_proto=True)
+
+      def _add_trackable_child(self, name, value):
+        self.__setattr__(name, value)
+    ```
+
+    Args:
+      proto: A `google.protobuf.Any` proto read from the `SavedModel`.
+      dependencies: A dictionary mapping names to dependencies (see
+        `_deserialization_dependencies`)
+      object_proto: The `SavedObject` proto for this object.
+      export_dir: The `SavedModel` directory
+      asset_file_def: The `MetaGraphDef`'s `asset_file_def` field.
+      operation_attributes: Dictionary mapping nodes to attribute from the
+        imported `GraphDef`.
+      **kwargs: Future keyword arguments passed to the object when loading.
+
+    Returns:
+      A new object.
+    """
+    del (proto, dependencies, object_proto, export_dir, asset_file_def,
+         operation_attributes, kwargs)
+
+    return cls()
+
+  def _add_trackable_child(self, name, value):
+    """Restores a connection between trackables when loading from SavedModel.
+
+    SavedModel stores both the object metadata and its list of children. When
+    loading, this function is used along with `_deserialize_from_proto` to load
+    objects from the SavedModel: First, all saved objects are created with
+    `_deserialize_from_proto`. After that is complete, the children are
+    connected using `_add_trackable_child`.
+
+    **Example**
+
+    `tf.Module`, `tf.keras.Model` and Keras layers use `__setattr__` to track
+    children. This is why users can call `model.v = tf.Variable(...)`, and the
+    variable will be automatically saved to the checkpoint. The implementation
+    of this method for the listed objects is:
+
+    ```
+    def _add_trackable_child(self, name, value):
+      self.__setattr__(name, value)
+    ```
+
+    Args:
+      name: The name of the connection between the parent and child `Trackable`.
+      value: The child `Trackable` object.
+    """
+    self._track_trackable(value, name, overwrite=True)
+
+  def _deserialization_dependencies(self, children):
+    """Returns a dictionary containing `Trackables` that this object depends on.
+
+    Dependencies define the order to serialize and deserialize objects in the
+    SavedModel. For example:
+
+    class A(Trackable):
+      b = B()
+      def _deserialization_dependencies(self, children):
+        return {'b': self.b}
+
+    class B(Trackable):
+      pass
+
+    We say that object `a=A()` depends on `a.b`.
+
+    Dependencies are guaranteed to be serialized and deserialized before the
+    object depending on them. The following methods use dependencies:
+      - `_deserialize_from_proto` [loading]
+
+    SavedModel loads with the bottom-up approach, by first creating all objects
+    in the order defined by the dependencies, then connecting the children.
+
+    Unlike `_trackable_children`, this function does not define the
+    `SavedObjectGraph`. It only changes the order in which things are
+    saved/loaded. Therefore, if there are dependencies that are not in the
+    `SavedObjectGraph`, saving will fail.
+
+    Args:
+      children: Dict returned from `_trackable_children`.
+
+    Returns:
+      A dictionary mapping names to `Trackable`.
+    """
+    del children  # Unused.
+    return {}
+
+  def _trackable_children(self,
+                          save_type=SaveType.CHECKPOINT,
+                          cache=None,
+                          **kwargs):
+    """Returns this object's `Trackable` attributes.
+
+    This method is used to build the object graph (or the object hierarchy,
+    in pickling terms) for checkpoint save/restore, and `SavedModel` export.
+
+    Override this method to define the children of this instance. Please read
+    the implementation restrictions:
+
+    **Rule 1: All children must be convertable to `Trackable`.**
+
+    Must pass `isinstance` check or `converter.convert_to_trackable`.
+
+    **Rule 2: [Checkpoint-only] Do not create new objects.**
+
+    When saving to a `SavedModel`, this method is called *exactly once* for each
+    `Trackable` in the object graph. When saving or restoring from a checkpoint,
+    this method may be called *multiple times*. Thus, this method may create
+    new Trackables when `save_type == SaveType.SAVEDMODEL` but not when
+    `save_type == SaveType.CHECKPOINT`.
+
+    When saving to `SavedModel`, new `Trackable` children can be created to save
+    non-Trackable attributes to the `SavedModel`. In the example below, `hyper`
+    is a regular python float hyperparameter. To save this value, a new Variable
+    is created to store the value of `hyper`:
+
+    ```
+    def __init__(self):
+      self.hyper = 1e-5
+
+    def _trackable_children(self, save_type, **unused_kwargs):
+      # Correct implementation
+      children = {}
+      if format == 'saved_model':
+        children['hyper'] = tf.Variable(self.hyper)
+      return children
+    ```
+
+    An incorrect implementation of `_trackable_children` is shown below. This
+    function would cause failures when loading the checkpoint, and calling
+    `load_status.assert_consumed()` or
+    `load_status.assert_existing_objects_matched`. If you want a value to be
+    saved in the checkpoint, hyper must be defined as a `tf.Variable` from the
+    start.
+
+    ```
+    def _trackable_children(self, save_type, **unused_kwargs):
+      # Incorrect implementation
+      return {'hyper': tf.Variable(self.hyper)}
+    ```
+
+    **Rule 3: [`SavedModel`-only] Watch out for un-traced tf.functions.**
+
+    At the begining of `_trackable_children`, always call
+    `get_concrete_function()` for any `tf.function` that has an input signature.
+
+    When `tf.functions` are saved to `SavedModel`, any `tf.functions` that have
+    an input signature and has never been called is traced at export time in
+    order to copy the op graph into the `SavedModel`. `tf.functions` that are
+    traced for the first time are allowed to create new state:
+
+
+    ```
+    @tf.function(input_signature=[]):
+    def fn(self);
+      if self.v is None:
+        self.v = tf.Variable(1.)
+      return self.v
+    ```
+
+    A problem occurs when there is a `Trackable` that returns `fn` as one of its
+    children and `self.v` has not been created yet. When `fn` is traced,
+    `self.v` is added to the `Trackable`, but `SavedModel` does not see this
+    modification since the `Trackable`'s children have already been gathered.
+
+    Therefore, as a precaution, call `get_concrete_function()` at the very
+    start of `_trackable_children` to ensure that the function is traced:
+
+
+    ```
+    def _trackable_children(self):
+      self.fn.get_concrete_function()
+      return {"v": self.v, "fn": self.fn}
+    ```
+
+    Args:
+      save_type: A string, can be 'savedmodel' or 'checkpoint'. Defaults to
+        SaveType.CHECKPOINT.
+      cache: May be `None`, or a dictionary. When `save_type == savedmodel`, a
+        new cache is created at the start of the SavedModel export, and shared
+        between all `Trackables` in the same object graph. This cache may be
+        used for advanced saving functionality.
+      **kwargs: Additional kwargs that may be added at a later time.
+
+    Returns:
+      Dictionary mapping names to child trackables.
+    """
+    del save_type, cache, kwargs  # Unused.
+
+    self._maybe_initialize_trackable()
+    return {name: ref for name, ref in self._checkpoint_dependencies}
+
+  def _export_to_saved_model_graph(self,
+                                   object_map,
+                                   tensor_map,
+                                   options,
+                                   **kwargs):
+    """Creates a copy of this object's tensors onto SavedModel graph.
+
+    Needs to be overridden if the class contains tensors that must be saved
+    into the graph. This method should update the `object_map` and `tensor_map`
+    dictionaries.
+
+    This method is called on all nodes in the Trackable Graph (generated by
+    `_trackable_children`). The nodes are traversed in the order defined by
+    `_deserialization_dependencies`
+
+    All usages of _map_resources should be migrated to this method.
+
+    Args:
+      object_map: A dictionary that maps original Trackables to the copied
+        Trackables. This only needs to be updated if the object is a
+        tf.function, or if the copied tensors are necessary for checkpointing
+        this object.
+      tensor_map: Dictionary mapping original tensors to copied tensors.
+      options: A `tf.saved_model.SaveOptions` object.
+      **kwargs: Additional kwargs that may be added at a later time.
+
+    Returns:
+      Flat list of original tensors that have been copied.
+    """
+    _, _, _ = object_map, tensor_map, options
+    del kwargs
+    return []
+
+  def _copy_trackable_to_cpu(self, object_map):
+    """Creates a copy of this object onto CPU, also copies values over.
+
+    Needs to be overridden if the `Trackable` requires AsyncCheckpoint support.
+    The method first checks whether a copy of `self` is already created in
+    `object_map`, and creates one if not already created. Then the method copies
+    the **values** of itself over to its copy mapped by `object_map`.
+
+    Args:
+      object_map: A dictionary that maps original Trackables to the copied
+        Trackables, which reside in the CPU.
+    """
+    del object_map  # Unused
+    raise NotImplementedError("Need to implement _copy_trackable_to_cpu() if "
+                              "the Trackable requires AsyncCheckpoint support.")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/base_delegate.py

@@ -0,0 +1,146 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A mixin class that delegates another Trackable to be used when saving.
+
+This is intended to be used with wrapper classes that cannot directly proxy the
+wrapped object (e.g. with wrapt.ObjectProxy), because there are inner attributes
+that cannot be exposed.
+
+The Wrapper class itself cannot contain any Trackable children, as only the
+delegated Trackable will be saved to checkpoint and SavedModel.
+
+This class will "disappear" and be replaced with the wrapped inner Trackable
+after a cycle of SavedModel saving and loading, unless the object is registered
+and loaded with Keras.
+"""
+
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("__internal__.tracking.DelegatingTrackableMixin", v1=[])
+class DelegatingTrackableMixin(object):
+  """A mixin that delegates all Trackable methods to another trackable object.
+
+  DO NOT USE THIS UNLESS YOU ARE THE KERAS LOSS SCALE OPTIMIZER.
+
+  This class must be used with multiple inheritance. A class that subclasses
+  Trackable can also subclass this class, which causes all Trackable methods to
+  be delegated to the trackable object passed in the constructor.
+
+  A subclass can use this mixin to appear as if it were the trackable passed to
+  the constructor, from a Checkpoint's perspective. LossScaleOptimizer uses this
+  mixin, so that the checkpoint format for a LossScaleOptimizer is identical to
+  the checkpoint format for a normal optimizer. This allows a model to be saved
+  with a normal Optimizer and restored with a LossScaleOptimizer, or vice versa.
+  The only difference in checkpoint format is that the loss scale is also saved
+  with a LossScaleOptimizer.
+  """
+
+  def __init__(self, trackable_obj):
+    self._trackable = trackable_obj
+
+  # pylint: disable=protected-access
+  @property
+  def _setattr_tracking(self):
+    return self._trackable._setattr_tracking
+
+  @_setattr_tracking.setter
+  def _setattr_tracking(self, value):
+    self._trackable._setattr_tracking = value
+
+  @property
+  def _update_uid(self):
+    return self._trackable._update_uid
+
+  @_update_uid.setter
+  def _update_uid(self, value):
+    self._trackable._update_uid = value
+
+  @property
+  def _unconditional_checkpoint_dependencies(self):
+    return self._trackable._unconditional_checkpoint_dependencies
+
+  @property
+  def _unconditional_dependency_names(self):
+    return self._trackable._unconditional_dependency_names
+
+  @property
+  def _name_based_restores(self):
+    return self._trackable._name_based_restores
+
+  def _maybe_initialize_trackable(self):
+    return self._trackable._maybe_initialize_trackable()
+
+  @property
+  def _object_identifier(self):
+    return self._trackable._object_identifier
+
+  @property
+  def _tracking_metadata(self):
+    return self._trackable._tracking_metadata
+
+  def _no_dependency(self, *args, **kwargs):
+    return self._trackable._no_dependency(*args, **kwargs)
+
+  def _name_based_attribute_restore(self, *args, **kwargs):
+    return self._trackable._name_based_attribute_restore(*args, **kwargs)
+
+  @property
+  def _checkpoint_dependencies(self):
+    return self._trackable._checkpoint_dependencies
+
+  @property
+  def _deferred_dependencies(self):
+    return self._trackable._deferred_dependencies
+
+  def _lookup_dependency(self, *args, **kwargs):
+    return self._trackable._lookup_dependency(*args, **kwargs)
+
+  def _add_variable_with_custom_getter(self, *args, **kwargs):
+    return self._trackable._add_variable_with_custom_getter(*args, **kwargs)
+
+  def _preload_simple_restoration(self, *args, **kwargs):
+    return self._trackable._preload_simple_restoration(*args, **kwargs)
+
+  def _track_trackable(self, *args, **kwargs):  # pylint: disable=redefined-outer-name
+    return self._trackable._track_trackable(*args, **kwargs)
+
+  def _handle_deferred_dependencies(self, name, trackable):  # pylint: disable=redefined-outer-name
+    return self._trackable._handle_deferred_dependencies(name, trackable)
+
+  def _gather_saveables_for_checkpoint(self, *args, **kwargs):
+    return self._trackable._gather_saveables_for_checkpoint(*args, **kwargs)
+
+  def _trackable_children(self, *args, **kwargs):
+    return self._trackable._trackable_children(*args, **kwargs)
+
+  def _deserialization_dependencies(self, *args, **kwargs):
+    return self._trackable._deserialization_dependencies(*args, **kwargs)
+
+  def _export_to_saved_model_graph(self, *args, **kwargs):
+    return self._trackable._export_to_saved_model_graph(*args, **kwargs)
+
+  def _serialize_to_tensors(self, *args, **kwargs):
+    return self._trackable._serialize_to_tensors(*args, **kwargs)
+
+  def _restore_from_tensors(self, *args, **kwargs):
+    return self._trackable._restore_from_tensors(*args, **kwargs)
+
+  def _copy_trackable_to_cpu(self, object_map):
+    self._trackable._copy_trackable_to_cpu(object_map)
+    if self not in object_map:
+      object_map[self] = DelegatingTrackableMixin(object_map[self._trackable])
+  # pylint: enable=protected-access
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/constants.py

@@ -0,0 +1,34 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Constants used in Trackable for checkpointing and serialization."""
+
+import enum
+
+
+# Key where the object graph proto is saved in a TensorBundle
+OBJECT_GRAPH_PROTO_KEY = "_CHECKPOINTABLE_OBJECT_GRAPH"
+
+# A key indicating a variable's value in an object's checkpointed Tensors
+# (Trackable._gather_saveables_for_checkpoint). If this is the only key and
+# the object has no dependencies, then its value may be restored on object
+# creation (avoiding double assignment when executing eagerly).
+VARIABLE_VALUE_KEY = "VARIABLE_VALUE"
+OBJECT_CONFIG_JSON_KEY = "OBJECT_CONFIG_JSON"
+
+
+@enum.unique
+class SaveType(str, enum.Enum):
+  SAVEDMODEL = "savedmodel"
+  CHECKPOINT = "checkpoint"

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/converter.py

@@ -0,0 +1,37 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Util for converting a Python object to a Trackable."""
+
+
+from tensorflow.python.eager.polymorphic_function import saved_model_utils
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.trackable import base
+from tensorflow.python.trackable import data_structures
+
+
+def convert_to_trackable(obj, parent=None):
+  """Converts `obj` to `Trackable`."""
+  if isinstance(obj, base.Trackable):
+    return obj
+  obj = data_structures.wrap_or_unwrap(obj)
+  if (tensor_util.is_tf_type(obj) and
+      obj.dtype not in (dtypes.variant, dtypes.resource) and
+      not resource_variable_ops.is_resource_variable(obj)):
+    return saved_model_utils.TrackableConstant(obj, parent)
+  if not isinstance(obj, base.Trackable):
+    raise ValueError(f"Cannot convert {obj} to Trackable.")
+  return obj

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/data_structures.py

@@ -0,0 +1,1112 @@
+"""Trackable data structures."""
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import collections
+import copy
+import sys
+
+try:
+  import wrapt
+except ImportError:
+  # Fall back to the build-time dependency if the system package is not available.
+  from .....third_party import wrapt  # pylint: disable=relative-beyond-top-level
+
+from tensorflow.python.eager import def_function
+from tensorflow.python.eager import function as defun
+from tensorflow.python.ops import variables
+from tensorflow.python.trackable import base
+from tensorflow.python.trackable import layer_utils
+from tensorflow.python.util.compat import collections_abc
+from tensorflow.python.util.tf_export import tf_export
+
+
+class NoDependency:
+  """Allows attribute assignment to `Trackable` objects with no dependency.
+
+  Example usage:
+  ```python
+  obj = Trackable()
+  obj.has_dependency = tf.Variable(0., name="dep")
+  obj.no_dependency = NoDependency(tf.Variable(1., name="nodep"))
+  assert obj.no_dependency.name == "nodep:0"
+  ```
+
+  `obj` in this example has a dependency on the variable "dep", and both
+  attributes contain un-wrapped `Variable` objects.
+
+  `NoDependency` also works with `tf.keras.Model`, but only for checkpoint
+  dependencies: wrapping a `Layer` in `NoDependency` will assign the (unwrapped)
+  `Layer` to the attribute without a checkpoint dependency, but the `Model` will
+  still track the `Layer` (so it will appear in `Model.layers`, and its
+  variables will appear in `Model.variables`).
+  """
+
+  __slots__ = ["value"]
+
+  def __init__(self, value):
+    self.value = value
+
+
+def _should_wrap_tuple(t):
+  """Determine if a tuple has any trackable components."""
+  # pylint: disable=unidiomatic-typecheck
+  # Exact type checking to avoid mucking up custom logic in list/dict
+  # subclasses, e.g. collections.Counter.
+  for element in t:
+    if isinstance(element, NoDependency):
+      return True  # We should remove the NoDependency object from the tuple.
+    if isinstance(element, base.Trackable):
+      return True
+    if type(element) == dict:
+      return True
+    if type(element) == collections.OrderedDict:
+      return True
+    if type(element) == list:
+      return True
+    if isinstance(element, tuple) and _should_wrap_tuple(element):
+      return True
+  # There are no trackable elements or data structures. Tuples are immutable, so
+  # mutation isn't a concern. Don't wrap.
+  return False
+  # pylint: enable=unidiomatic-typecheck
+
+
+@tf_export("__internal__.tracking.wrap", v1=[])
+def wrap_or_unwrap(value):
+  """Wraps input value into trackable data structures.
+
+  This is mostly useful for containers like list, dict, etc, which could contain
+  trackable objects in it. Wrapped data structure will be tracked when
+  associated with a `tf.Module`, so that save model/checkpoint can properly
+  track the dependency.
+
+  It will also unwrap NoDependency objects.
+
+  Args:
+    value: the input object to be wrapped.
+
+  Returns:
+    Wrapped trackable data structure.
+  """
+  # pylint: disable=unidiomatic-typecheck
+  # Exact type checking to avoid mucking up custom logic in list/dict
+  # subclasses, e.g. collections.Counter.
+  if isinstance(value, NoDependency):
+    return value.value
+  if isinstance(value, base.Trackable):
+    return value  # Skip conversion for already trackable objects.
+  elif type(value) == dict:
+    return _DictWrapper(value)
+  elif type(value) == collections.OrderedDict:
+    return _DictWrapper(value)
+  elif type(value) == list:
+    return ListWrapper(value)
+  elif isinstance(value, tuple) and _should_wrap_tuple(value):
+    # There are trackable elements or data structures. Wrap the tuple.
+    return _TupleWrapper(value)
+  else:
+    return value
+  # pylint: enable=unidiomatic-typecheck
+
+
+@tf_export("__internal__.tracking.sticky_attribute_assignment", v1=[])
+def sticky_attribute_assignment(trackable, name, value):
+  """Adds dependencies, generally called from __setattr__.
+
+  This behavior is shared between Trackable and Model.
+
+  Respects NoDependency indicators, but otherwise makes trackable objects
+  out of common data structures and tracks objects by their attribute names.
+
+  Args:
+    trackable: The object to add dependencies to (generally the one having
+      an attribute assigned).
+    name: The attribute name being assigned.
+    value: The value being assigned. Not necessarily a trackable object.
+
+  Returns:
+    The value which should be stored in the attribute (unwrapped from a
+    NoDependency object if necessary).
+  """
+  if isinstance(value, NoDependency):
+    add_dependency = False
+  else:
+    add_dependency = True
+  value = wrap_or_unwrap(value)
+  if not add_dependency:
+    return value
+  if isinstance(value, base.Trackable):
+    trackable._track_trackable(  # pylint: disable=protected-access
+        value, name=name,
+        # Allow the user to switch the Trackable which is tracked by this
+        # name, since assigning a new variable to an attribute has
+        # historically been fine (e.g. Adam did this).
+        overwrite=True)
+  return value
+
+
+class _UntrackableError(ValueError):
+
+  def __init__(self, value):  # pylint: disable=super-init-not-called
+    self._value = value
+
+  def __str__(self):
+    return ("Only trackable objects (such as Layers or Optimizers) may be "
+            f"stored in a List object. Got {self._value}, which does not "
+            "inherit from Trackable.")
+
+
+@tf_export("__internal__.tracking.TrackableDataStructure", v1=[])
+class TrackableDataStructure(base.Trackable):
+  """Base class for data structures which contain trackable objects."""
+
+  def __init__(self):
+    # Attributes prefixed with "_self_" for compatibility with
+    # wrapt.ObjectProxy. All additional attrs MUST conform to this pattern, as
+    # extending `__slots__` on a subclass of ObjectProxy breaks in a variety of
+    # ways.
+    self._self_trainable = True
+    self._self_extra_variables = []
+    self._self_attribute_sentinel = layer_utils.AttributeSentinel(True)
+
+  @property
+  def _attribute_sentinel(self):
+    return self._self_attribute_sentinel
+
+  @property
+  def trainable(self):
+    return self._self_trainable
+
+  @trainable.setter
+  def trainable(self, value):
+    self._self_trainable = value
+
+  def _track_value(self, value, name):
+    """Add a dependency on `value`."""
+    value = sticky_attribute_assignment(
+        trackable=self, value=value, name=name)
+    if isinstance(value, variables.Variable):
+      self._self_extra_variables.append(value)
+    if not isinstance(value, base.Trackable):
+      raise _UntrackableError(value)
+    if hasattr(value, "_use_resource_variables"):
+      # In subclassed models, legacy layers (tf.layers) must always use
+      # resource variables.
+      value._use_resource_variables = True  # pylint: disable=protected-access
+    value_attribute_sentinel = getattr(value, "_attribute_sentinel", None)
+    if value_attribute_sentinel:
+      value_attribute_sentinel.add_parent(self._attribute_sentinel)
+    return value
+
+  @property
+  def _values(self):
+    """An iterable/sequence which may contain trackable objects."""
+    raise NotImplementedError("Abstract method")
+
+  @property
+  def _layers(self):
+    """All Layers and Layer containers, including empty containers."""
+    # Filter objects on demand so that wrapper objects use values from the thing
+    # they're wrapping if out of sync.
+    collected = []
+    for obj in self._values:
+      if (isinstance(obj, TrackableDataStructure)
+          or layer_utils.is_layer(obj)
+          or layer_utils.has_weights(obj)):
+        collected.append(obj)
+    return collected
+
+  @property
+  def layers(self):
+    return list(layer_utils.filter_empty_layer_containers(self._layers))
+
+  @property
+  def trainable_weights(self):
+    if not self._self_trainable:
+      return []
+    trainable_variables = []
+    for obj in self._values:
+      if isinstance(obj, base.Trackable) and hasattr(
+          obj, "trainable_variables"):
+        trainable_variables += obj.trainable_variables
+    trainable_extra_variables = [
+        v for v in self._self_extra_variables if v.trainable
+    ]
+    return trainable_variables + trainable_extra_variables
+
+  @property
+  def non_trainable_weights(self):
+    trainable_extra_variables = [
+        v for v in self._self_extra_variables if v.trainable
+    ]
+    non_trainable_extra_variables = [
+        v for v in self._self_extra_variables if not v.trainable
+    ]
+    non_trainable_variables = []
+    for obj in self._values:
+      if isinstance(obj, base.Trackable) and hasattr(
+          obj, "non_trainable_variables"):
+        non_trainable_variables += obj.non_trainable_variables
+
+    if not self._self_trainable:
+      # Return order is all trainable vars, then all non-trainable vars.
+      trainable_variables = []
+      for obj in self._values:
+        if isinstance(obj, base.Trackable) and hasattr(
+            obj, "trainable_variables"):
+          trainable_variables += obj.trainable_variables
+
+      non_trainable_variables = (
+          trainable_variables + trainable_extra_variables +
+          non_trainable_variables + non_trainable_extra_variables)
+    else:
+      non_trainable_variables = (
+          non_trainable_variables + non_trainable_extra_variables)
+
+    return non_trainable_variables
+
+  @property
+  def weights(self):
+    return self.trainable_weights + self.non_trainable_weights
+
+  @property
+  def trainable_variables(self):
+    return self.trainable_weights
+
+  @property
+  def non_trainable_variables(self):
+    return self.non_trainable_weights
+
+  @property
+  def variables(self):
+    return self.weights
+
+  @property
+  def updates(self):
+    """Aggregate updates from any `Layer` instances."""
+    # Updates and conditional losses are forwarded as-is rather than being
+    # filtered based on inputs, since this is just a container and won't ever
+    # have any inputs.
+    aggregated = []
+    for layer in self.layers:
+      if hasattr(layer, "updates"):
+        aggregated += layer.updates
+    return aggregated
+
+  @property
+  def losses(self):
+    """Aggregate losses from any `Layer` instances."""
+    aggregated = []
+    for layer in self.layers:
+      if hasattr(layer, "losses"):
+        aggregated += layer.losses
+    return aggregated
+
+  def __hash__(self):
+    # Support object-identity hashing, so these structures can be used as keys
+    # in sets/dicts.
+    return id(self)
+
+  def __eq__(self, other):
+    # Similar to Tensors, trackable data structures use object-identity
+    # equality to support set/dict membership.
+    return self is other
+
+
+class List(TrackableDataStructure, collections_abc.Sequence):
+  """An append-only sequence type which is trackable.
+
+  Maintains checkpoint dependencies on its contents (which must also be
+  trackable), and forwards any `Layer` metadata such as updates and losses.
+
+  Note that `List` is purely a container. It lets a `tf.keras.Model` or
+  other trackable object know about its contents, but does not call any
+  `Layer` instances which are added to it. To indicate a sequence of `Layer`
+  instances which should be called sequentially, use `tf.keras.Sequential`.
+
+  Example usage:
+  ```python
+  class HasList(tf.keras.Model):
+
+    def __init__(self):
+      super().__init__()
+      self.layer_list = List([layers.Dense(3)])
+      self.layer_list.append(layers.Dense(4))
+
+    def call(self, x):
+      aggregation = 0.
+      for l in self.layer_list:
+        x = l(x)
+        aggregation += tf.reduce_sum(x)
+      return aggregation
+  ```
+
+  This kind of wrapping is necessary because `Trackable` objects do not
+  (yet) deeply inspect regular Python data structures, so for example assigning
+  a regular list (`self.layer_list = [layers.Dense(3)]`) does not create a
+  checkpoint dependency and does not add the `Layer` instance's weights to its
+  parent `Model`.
+  """
+
+  def __init__(self, *args, **kwargs):
+    """Construct a new sequence. Arguments are passed to `list()`."""
+    super().__init__()
+    self._storage = self._make_storage(*args, **kwargs)
+    for index, element in enumerate(self._storage):
+      self._storage[index] = self._track_value(
+          element, name=self._name_element(index))
+
+  def copy(self):
+    return type(self)(copy.copy(self._storage))
+
+  def __copy__(self):
+    return self.copy()
+
+  def __deepcopy__(self, memo):
+    return type(self)(copy.deepcopy(self._storage, memo))
+
+  def _make_storage(self, *args, **kwargs):
+    """Determines the backing storage (overridden in subclasses)."""
+    return list(*args, **kwargs)
+
+  def _name_element(self, index):
+    return "%d" % (index,)
+
+  @property
+  def _values(self):
+    """Collect values for TrackableDataStructure."""
+    return self
+
+  def append(self, value):
+    """Add a new trackable value."""
+    value = self._track_value(value, self._name_element(len(self._storage)))
+    self._storage.append(value)
+
+  def extend(self, values):
+    """Add a sequence of trackable values."""
+    for value in values:
+      self.append(value)
+
+  def __iadd__(self, values):
+    self.extend(values)
+    return self
+
+  def __add__(self, other):
+    return self._storage + getattr(other, "_storage", other)
+
+  def __imul__(self, y):
+    if y <= 0:
+      raise ValueError(
+          f"List only supports append, multiplying in place by {y} removes "
+          "elements.")
+
+    n = len(self._storage)
+    for _ in range(y - 1):
+      for i in range(n):
+        self.append(self._storage[i])
+
+    return self
+
+  def __mul__(self, n):
+    return self._storage * n
+
+  def __rmul__(self, n):
+    return self * n
+
+  def __radd__(self, other):
+    return other + self._storage
+
+  def __getitem__(self, key):
+    return self._storage[key]
+
+  def __getslice__(self, i, j):
+    return self._storage[slice(i, j)]
+
+  def __len__(self):
+    return len(self._storage)
+
+  def __repr__(self):
+    return "List(%s)" % (repr(self._storage),)
+
+  def __sizeof__(self):
+    return super().__sizeof__() + sys.getsizeof(self._storage)
+
+
+# TODO(tomhennigan) Update to collections.UserList?
+# TODO(allenl): Try switching this to wrapt.ObjectProxy again when we drop
+# Python 3.4 support (may still be tricky).
+class ListWrapper(
+    List,
+    collections_abc.MutableSequence,
+    # Shadowed, but there for isinstance checks.
+    list):
+  """Wraps the built-in `list` to support restore-on-create for variables.
+
+  Unlike `List`, this sequence type is mutable in the same ways built-in lists
+  are. Instead of throwing an error immediately like `List`, it records
+  problematic mutations (e.g. assigning a new element to a position already
+  occupied, meaning both elements get the same names at different times) and
+  refuses to save.
+
+  On assignment to an attribute of a Model or Trackable object, Python
+  lists are replaced with ListWrapper. Wrapping a list in a
+  `NoDependency` object prevents this.
+  """
+
+  def __init__(self, wrapped_list):
+    """Construct a new list wrapper.
+
+    Args:
+      wrapped_list: The initial value of the data structure. A shallow copy may
+        be maintained for error checking. `wrapped_list` itself should not be
+        modified directly after constructing the `ListWrapper`, and if changes
+        are detected the `ListWrapper` will throw an exception on save.
+    """
+    # Monotonic flags which indicate this object would not be restored properly,
+    # and therefore should throw an error on save to avoid giving the impression
+    # that restoring it will work.
+    self._non_append_mutation_value = False
+    self._external_modification_value = False
+    super().__init__(wrapped_list)
+    self._last_wrapped_list_snapshot = list(self._storage)
+
+  @property
+  def _non_append_mutation(self):
+    return self._non_append_mutation_value
+
+  @_non_append_mutation.setter
+  def _non_append_mutation(self, value):
+    # Trackable only cares that a mutation occurred at some point; when
+    # attempting to save it checks whether a mutation occurred and the object is
+    # in a "dirty" state but otherwise the specifics of how it got to that state
+    # are ignored. By contrast, the attribute cache needs to signal the mutation
+    # immediately since a caller could query the value of an attribute (And
+    # should not hit the cached value since the mutation may have affected the
+    # result.)
+    self._attribute_sentinel.invalidate_all()
+    self._non_append_mutation_value = value
+
+  @property
+  def _external_modification(self):
+    return self._external_modification_value
+
+  @_external_modification.setter
+  def _external_modification(self, value):
+    # Invalidate for the same reason as `_non_append_mutation`
+    self._attribute_sentinel.invalidate_all()
+    self._external_modification_value = value
+
+  # pylint: disable=protected-access
+  def __copy__(self):
+    copied = super().__copy__()
+    copied._non_append_mutation = self._non_append_mutation
+    copied._external_modification = self._external_modification
+    return copied
+
+  def __deepcopy__(self, memo):
+    copied = super().__deepcopy__(memo)
+    copied._non_append_mutation = self._non_append_mutation
+    copied._external_modification = self._external_modification
+    return copied
+  # pylint: enable=protected-access
+
+  def __reduce_ex__(self, protocol):
+    return (self.__class__,
+            (self._storage,))
+
+  def _make_storage(self, wrapped_list):
+    """Use the user's original list for storage."""
+    return wrapped_list
+
+  def _check_external_modification(self):
+    """Checks for any changes to the wrapped list not through the wrapper."""
+    if self._external_modification or self._non_append_mutation:
+      return
+    if self._storage != self._last_wrapped_list_snapshot:
+      self._external_modification = True
+      self._last_wrapped_list_snapshot = None
+
+  def _update_snapshot(self):
+    """Acknowledges tracked changes to the wrapped list."""
+
+    # Mutation tracking for attributes reuses the same infrastructure as
+    # Trackable mutation tracking.
+    self._attribute_sentinel.invalidate_all()
+    if self._external_modification or self._non_append_mutation:
+      return
+    self._last_wrapped_list_snapshot = list(self._storage)
+
+  def _trackable_children(self, save_type=base.SaveType.CHECKPOINT, **kwargs):
+    self._check_external_modification()
+    if self._non_append_mutation:
+      raise ValueError(
+          f"Unable to save the object {self} (a list wrapper constructed to "
+          "track trackable TensorFlow objects). A list element was replaced "
+          "(__setitem__, __setslice__), deleted (__delitem__, __delslice__), "
+          "or moved (sort). In order to support restoration on object "
+          "creation, tracking is exclusively for append-only data structures."
+          "\n\nIf you don't need this list checkpointed, wrap it in a "
+          "non-trackable object; it will be subsequently ignored.")
+    if self._external_modification:
+      raise ValueError(
+          f"Unable to save the object {self} (a list wrapper constructed to "
+          "track trackable TensorFlow objects). The wrapped list was modified "
+          f"outside the wrapper (its final value was {self._storage}, its value"
+          " when a checkpoint dependency was added was "
+          f"{self._last_wrapped_list_snapshot}), which breaks "
+          "restoration on object creation.\n\nIf you don't need this list "
+          "checkpointed, wrap it in a NoDependency object; it will be "
+          "subsequently ignored.")
+    children = super()._trackable_children(save_type, **kwargs)
+
+    if save_type == base.SaveType.SAVEDMODEL:
+      # Add functions to be serialized.
+      children.update({
+          str(key): value
+          for key, value in enumerate(self)
+          if _is_function(value)
+      })
+
+    return children
+
+  def _has_mutation_or_trackable(self):
+    """Short-circuits a check for trackables if there's already a mutation."""
+    if self._non_append_mutation:
+      return True
+    return any(isinstance(element, base.Trackable) for element in self._storage)
+
+  def __delitem__(self, key):
+    self._check_external_modification()
+    if self._has_mutation_or_trackable():
+      self._non_append_mutation = True
+    del self._storage[key]
+    self._update_snapshot()
+
+  def __setitem__(self, key, value):
+    self._check_external_modification()
+
+    if isinstance(key, slice):
+      # Note: this is quite inefficient, but the list API supports a broad range
+      # of slice setters (e.g. truncate, extend, replace) and imitating this
+      # for a range of Python versions is non-trivial.
+      storage_copy = list(self._storage)
+      self._storage[key] = value
+
+      len_before = len(storage_copy)
+      len_now = len(self._storage)
+      for i in range(max(len_before, len_now)):
+        value_now = self._storage[i] if i < len_now else None
+        value_before = storage_copy[i] if i < len_before else None
+
+        if isinstance(value_before, base.Trackable):
+          self._non_append_mutation = True
+
+        if value_now is not None and value_now != value_before:
+          self._storage[i] = self._track_value(self._storage[i],
+                                               self._name_element(i))
+
+    else:
+      if isinstance(self._storage[key], base.Trackable):
+        self._non_append_mutation = True
+      self._storage[key] = self._track_value(value, self._name_element(key))
+
+    self._update_snapshot()
+
+  def append(self, value):
+    """Add a new trackable value."""
+    self._check_external_modification()
+    super().append(value)
+    self._update_snapshot()
+
+  def extend(self, values):
+    """Add a sequence of trackable values."""
+    self._check_external_modification()
+    super().extend(values)
+    self._update_snapshot()
+
+  def __imul__(self, y):
+    if y <= 0:
+      self._check_external_modification()
+      if self._has_mutation_or_trackable():
+        self._non_append_mutation = True
+      self._storage *= y
+      self._update_snapshot()
+      return self
+
+    # Relies on super() calling append, which updates the snapshot.
+    return super().__imul__(y)
+
+  def __eq__(self, other):
+    return self._storage == getattr(other, "_storage", other)
+
+  def __ne__(self, other):
+    return self._storage != getattr(other, "_storage", other)
+
+  def __lt__(self, other):
+    return self._storage < getattr(other, "_storage", other)
+
+  def __le__(self, other):
+    return self._storage <= getattr(other, "_storage", other)
+
+  def __gt__(self, other):
+    return self._storage > getattr(other, "_storage", other)
+
+  def __ge__(self, other):
+    return self._storage >= getattr(other, "_storage", other)
+
+  def __hash__(self):
+    # List wrappers need to compare like regular lists, and so like regular
+    # lists they don't belong in hash tables.
+    raise TypeError("unhashable type: 'ListWrapper'")
+
+  def insert(self, index, obj):
+    self._check_external_modification()
+    if (self._has_mutation_or_trackable() or isinstance(obj, base.Trackable)):
+      self._non_append_mutation = True
+    self._storage.insert(index, obj)
+    self._update_snapshot()
+
+  def sort(self):
+    self._check_external_modification()
+    if self._has_mutation_or_trackable():
+      self._non_append_mutation = True
+    self._storage.sort()
+    self._update_snapshot()
+
+  def __setslice__(self, i, j, y):
+    self.__setitem__(slice(i, j), y)
+
+  def __delslice__(self, i, j):
+    self._check_external_modification()
+    if self._has_mutation_or_trackable():
+      self._non_append_mutation = True
+    del self._storage[slice(i, j)]
+    self._update_snapshot()
+
+  def _track_value(self, value, name):
+    """Allows storage of non-trackable objects."""
+    try:
+      value = super()._track_value(value=value, name=name)
+    except ValueError:
+      # Even if this value isn't trackable, we need to make sure
+      # NoDependency objects get unwrapped.
+      value = sticky_attribute_assignment(
+          trackable=self, value=value, name=name)
+    return value
+
+  def __repr__(self):
+    return "ListWrapper(%s)" % (repr(self._storage),)
+
+
+class Mapping(TrackableDataStructure, collections_abc.Mapping):
+  """An append-only trackable mapping data structure with string keys.
+
+  Maintains checkpoint dependencies on its contents (which must also be
+  trackable), named based on its keys.
+
+  Note that once a key has been added, it may not be deleted or replaced.
+  """
+
+  def __init__(self, *args, **kwargs):
+    """Construct a new sequence. Arguments are passed to `dict()`."""
+    super().__init__()
+    self._storage = self._make_storage(*args, **kwargs)
+    self._storage.update(
+        {key: self._track_value(
+            value, name=self._name_element(key))
+         for key, value in self._storage.items()})
+
+  def __copy__(self):
+    return type(self)(copy.copy(self._storage))
+
+  def __deepcopy__(self, memo):
+    return type(self)(copy.deepcopy(self._storage, memo))
+
+  def _make_storage(self, *args, **kwargs):
+    return dict(*args, **kwargs)
+
+  @property
+  def _values(self):
+    """Collect values for TrackableDataStructure."""
+    # Sort items deterministically by key
+    ordered = list(zip(*sorted(self.items(), key=lambda it: it[0])))
+    if ordered:
+      return ordered[1]
+    return []
+
+  def _name_element(self, key):
+    if not isinstance(key, str):
+      raise TypeError(
+          f"Mapping accepts only string keys, but got a key {repr(key)}.")
+    return str(key)
+
+  def __setitem__(self, key, value):
+    name = self._name_element(key)
+    value = self._track_value(value, name=name)
+    current_value = self._storage.setdefault(key, value)
+    if current_value is not value:
+      raise ValueError(
+          "Mappings are an append-only data structure. Tried to overwrite the "
+          f"key '{key}' with value {value}, but it already contains "
+          f"{current_value}")
+
+  def update(self, *args, **kwargs):
+    for key, value in dict(*args, **kwargs).items():
+      self[key] = value
+
+  def __getitem__(self, key):
+    return self._storage[key]
+
+  def __len__(self):
+    return len(self._storage)
+
+  def __repr__(self):
+    return "Mapping(%s)" % (repr(self._storage),)
+
+  def __iter__(self):
+    return iter(self._storage)
+
+
+class _DictWrapper(TrackableDataStructure, wrapt.ObjectProxy):
+  """Wraps built-in dicts to support restore-on-create for variables.
+
+  _DictWrapper is to Mapping as ListWrapper is to List. Unlike Mapping,
+  _DictWrapper allows non-string keys and values and arbitrary mutations (delete
+  keys, reassign values). Like ListWrapper, these mutations mean that
+  _DictWrapper will raise an exception on save.
+  """
+
+  def __init__(self, wrapped_dict=None):
+    if wrapped_dict is None:
+      # Allow zero-argument construction, e.g. from session.run's re-wrapping.
+      wrapped_dict = {}
+    if not isinstance(wrapped_dict, collections_abc.Mapping):
+      # Allow construction from a sequence, e.g. from nest.pack_sequence_as.
+      wrapped_dict = dict(wrapped_dict)
+    wrapt.ObjectProxy.__init__(self, wrapped_dict)
+    TrackableDataStructure.__init__(self)
+    self._self_non_string_key = False
+    self._self_external_modification = False
+    self.__wrapped__.update(
+        {key: self._track_value(
+            value, name=self._name_element(key))
+         for key, value in self.__wrapped__.items()})
+    self._update_snapshot()
+
+  def __reduce_ex__(self, protocol):
+    return (self.__class__,
+            (self.__wrapped__,))
+
+  def __getattribute__(self, name):
+    if (hasattr(type(self), name)
+        and isinstance(getattr(type(self), name), property)):
+      # Bypass ObjectProxy for properties. Whether this workaround is necessary
+      # appears to depend on the Python version but not the wrapt version: 3.4
+      # in particular seems to look up properties on the wrapped object instead
+      # of the wrapper without this logic.
+      return object.__getattribute__(self, name)
+    else:
+      return super().__getattribute__(name)
+
+  def copy(self):
+    return copy.copy(self)
+
+  # pylint: disable=protected-access
+  def __copy__(self):
+    copied = _DictWrapper(copy.copy(self.__wrapped__))
+    copied._self_external_modification = self._self_external_modification
+    copied._self_non_string_key = self._self_non_string_key
+    return copied
+
+  def __deepcopy__(self, memo):
+    copied = _DictWrapper(copy.deepcopy(self.__wrapped__, memo))
+    copied._self_external_modification = self._self_external_modification
+    copied._self_non_string_key = self._self_non_string_key
+    return copied
+  # pylint: enable=protected-access
+
+  @property
+  def _values(self):
+    """Collect values for TrackableDataStructure."""
+    # Sort items deterministically by key
+    ordered = list(zip(*sorted(self.items(), key=lambda it: it[0])))
+    if ordered:
+      return ordered[1]
+    return []
+
+  def _trackable_children(self, save_type=base.SaveType.CHECKPOINT, **kwargs):
+    """Check that the object is saveable before listing its dependencies."""
+    self._check_self_external_modification()
+    if self._self_non_string_key:
+      raise ValueError(
+          f"Unable to save the object {self} (a dictionary wrapper constructed "
+          "automatically on attribute assignment). The wrapped dictionary "
+          "contains a non-string key which maps to a trackable object or "
+          "mutable data structure.\n\nIf you don't need this dictionary "
+          "checkpointed, wrap it in a non-trackable "
+          "object; it will be subsequently ignored.")
+    if self._self_external_modification:
+      raise ValueError(
+          f"Unable to save the object {self} (a dictionary wrapper constructed "
+          "automatically on attribute assignment). The wrapped dictionary was "
+          f"modified outside the wrapper (its final value was {self}, its value"
+          " when a checkpoint dependency was added was "
+          f"{self._self_last_wrapped_dict_snapshot}), which breaks "
+          "restoration on object creation.\n\nIf you don't need this "
+          "dictionary checkpointed, wrap it in a "
+          "non-trackable object; it will be subsequently ignored.")
+    assert not self._dirty  # Any reason for dirtiness should have an exception.
+    children = super()._trackable_children(save_type, **kwargs)
+
+    if save_type == base.SaveType.SAVEDMODEL:
+      # Add functions to be serialized.
+      children.update(
+          {key: value for key, value in self.items() if _is_function(value)})
+
+    return children
+
+  @property
+  def _dirty(self):
+    """Check if there has already been a mutation which prevents saving."""
+    return (self._self_external_modification
+            or self._self_non_string_key)
+
+  def _check_self_external_modification(self):
+    """Checks for any changes to the wrapped dict not through the wrapper."""
+    if self._dirty:
+      return
+    if self != self._self_last_wrapped_dict_snapshot:
+      self._self_external_modification = True
+      self._self_last_wrapped_dict_snapshot = None
+
+  def _update_snapshot(self):
+    """Acknowledges tracked changes to the wrapped dict."""
+    self._attribute_sentinel.invalidate_all()
+    if self._dirty:
+      return
+    self._self_last_wrapped_dict_snapshot = dict(self)
+
+  def _track_value(self, value, name):
+    """Allows storage of non-trackable objects."""
+    if isinstance(name, str):
+      string_key = True
+    else:
+      name = "-non_string_key"
+      string_key = False
+    try:
+      no_dependency = isinstance(value, NoDependency)
+      value = super()._track_value(value=value, name=name)
+      if not (string_key or no_dependency):
+        # A non-string key maps to a trackable value. This data structure
+        # is not saveable.
+        self._self_non_string_key = True
+      return value
+    except ValueError:
+      # Even if this value isn't trackable, we need to make sure
+      # NoDependency objects get unwrapped.
+      return sticky_attribute_assignment(
+          trackable=self, value=value, name=name)
+
+  def _name_element(self, key):
+    """Tells TrackableDataStructure to use keys as names as-is."""
+    return key
+
+  def __setitem__(self, key, value):
+    """Allow any modifications, but possibly mark the wrapper as unsaveable."""
+    self._check_self_external_modification()
+    self._maybe_initialize_trackable()
+    no_dep = isinstance(value, NoDependency)
+    if isinstance(key, str):
+      value = self._track_value(value, name=key)
+    else:
+      value = wrap_or_unwrap(value)
+      if not no_dep and isinstance(value, base.Trackable):
+        # Non-string keys are OK as long as we have no reason to add a
+        # dependency on the value (either because the value is not
+        # trackable, or because it was wrapped in a NoDependency object).
+        self._self_non_string_key = True
+    self.__wrapped__[key] = value
+
+    self._update_snapshot()
+
+  def __delitem__(self, key):
+    self._check_self_external_modification()
+    del self.__wrapped__[key]
+    self._update_snapshot()
+
+  def __repr__(self):
+    return "DictWrapper(%s)" % (repr(self.__wrapped__),)
+
+  def __hash__(self):
+    raise TypeError("unhashable type: 'DictWrapper'")
+
+  def __eq__(self, other):
+    # Override the TrackableDataStructure "== -> is" forwarding and go back to
+    # the wrapt implementation.
+    return self.__wrapped__ == other
+
+  def update(self, *args, **kwargs):
+    for key, value in dict(*args, **kwargs).items():
+      self[key] = value
+
+
+class _TupleWrapper(TrackableDataStructure, wrapt.ObjectProxy):
+  """Trackable wrapper for tuples and namedtuples."""
+
+  def __init__(self, original_wrapped_tuple=()):
+    add_dependency = []
+    substituted_wrapped_tuple = []
+    for element in original_wrapped_tuple:
+      if isinstance(element, NoDependency):
+        add_dependency.append(False)
+      else:
+        add_dependency.append(True)
+      substituted_wrapped_tuple.append(wrap_or_unwrap(element))
+    try:
+      fields = original_wrapped_tuple._fields
+    except AttributeError:
+      # Not a namedtuple
+      is_namedtuple = False
+    else:
+      is_namedtuple = True
+    original_type = type(original_wrapped_tuple)
+    # Flag to poison saving if we can't re-construct a namedtupled because its
+    # __new__ takes different keyword arguments than its _fields.
+    self._self_tuple_is_constructable = True
+    if is_namedtuple:
+      try:
+        # NamedTuples take N arguments, unlike tuple which takes a sequence.
+        substituted_wrapped_tuple = original_type(
+            **dict(zip(fields, substituted_wrapped_tuple)))
+      except TypeError:
+        wrapt.ObjectProxy.__init__(self, original_wrapped_tuple)
+        TrackableDataStructure.__init__(self)
+        self._self_tuple_is_constructable = False
+        return
+    else:
+      substituted_wrapped_tuple = original_type(substituted_wrapped_tuple)
+    wrapt.ObjectProxy.__init__(self, substituted_wrapped_tuple)
+    TrackableDataStructure.__init__(self)
+
+    if is_namedtuple:
+      # For namedtuples, also track by names for compatibility with
+      # dictionaries.
+      for name, should_depend, element in zip(
+          fields, add_dependency, substituted_wrapped_tuple):
+        if should_depend:
+          self._track_value(element, name=name)
+
+    # Track by index as well, for compatibility with lists.
+    for index, (should_depend, element) in enumerate(
+        zip(add_dependency, substituted_wrapped_tuple)):
+      if should_depend:
+        self._track_value(element, name="%d" % (index,))
+
+  @property
+  def _values(self):
+    """Collect values for TrackableDataStructure."""
+    return self
+
+  def _track_value(self, value, name):
+    """Allows storage of non-trackable objects."""
+    try:
+      value = super()._track_value(value=value, name=name)
+    except ValueError:
+      # Even if this value isn't trackable, we need to make sure
+      # NoDependency objects get unwrapped.
+      value = sticky_attribute_assignment(
+          trackable=self, value=value, name=name)
+    return value
+
+  def __repr__(self):
+    return "_TupleWrapper(%s)" % (repr(self.__wrapped__),)
+
+  def __hash__(self):
+    # Override the TrackableDataStructure hash forwarding and go back to
+    # the wrapt implementation.
+    return hash(self.__wrapped__)
+
+  def __eq__(self, other):
+    # Override the TrackableDataStructure "== -> is" forwarding and go back to
+    # the wrapt implementation.
+    return self.__wrapped__ == other
+
+  def __copy__(self):
+    return _TupleWrapper(copy.copy(self.__wrapped__))
+
+  def __deepcopy__(self, memo):
+    return _TupleWrapper(copy.deepcopy(self.__wrapped__, memo))
+
+  def __reduce_ex__(self, protocol):
+    return (self.__class__,
+            (self.__wrapped__,))
+
+  # imul and iadd are the only tuple-relevant in-place operators. They need to
+  # be special-cased to avoid mutating the original proxy object.
+  def __imul__(self, y):
+    """Avoid running self.__wrapped__ *= y, which mutates `self`."""
+    return self.__wrapped__ * y
+
+  def __iadd__(self, y):
+    """Avoid running self.__wrapped__ += y, which mutates `self`."""
+    return self.__wrapped__ + y
+
+  def _trackable_children(self, save_type=base.SaveType.CHECKPOINT, **kwargs):
+    if not self._self_tuple_is_constructable:
+      raise ValueError(
+          f"Unable to save because the namedtuple {self.__wrapped__} is not "
+          "constructable from its _fields (i.e. __new__ is overridden). "
+          f"Expected keyword arguments {self.__wrapped__._fields}. If you do "
+          "not need to save this object, consider wrapping it in a custom "
+          "object that does not inherit from tuple.")
+    return super()._trackable_children(save_type, **kwargs)
+
+  def __getattribute__(self, name):
+    if name != "__wrapped__" and hasattr(self.__wrapped__, name):
+      # Prefer attributes on the wrapped object when they conflict with
+      # attributes on the wrapper object.
+      return getattr(self.__wrapped__, name)
+
+    if (hasattr(type(self), name)
+        and isinstance(getattr(type(self), name), property)):
+      # Bypass ObjectProxy for properties. Whether this workaround is necessary
+      # appears to depend on the Python version but not the wrapt version: 3.4
+      # in particular seems to look up properties on the wrapped object instead
+      # of the wrapper without this logic.
+      return object.__getattribute__(self, name)
+    else:
+      return super().__getattribute__(name)
+
+
+def _is_function(x):
+  return isinstance(x, (def_function.Function, defun.ConcreteFunction))
+
+
+def set_list_item(list_object, index_string, value):
+  item_index = int(index_string)
+  if len(list_object) <= item_index:
+    list_object.extend([None] * (1 + item_index - len(list_object)))
+  list_object[item_index] = value
+
+
+def set_tuple_item(list_object, index_string, value):
+  try:
+    item_index = int(index_string)
+  except ValueError:
+    # Ignore namedtuple fields.
+    return
+  if len(list_object) <= item_index:
+    list_object.extend([None] * (1 + item_index - len(list_object)))
+  list_object[item_index] = value

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/layer_utils.py

@@ -0,0 +1,141 @@
+# 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.
+# ==============================================================================
+"""Utilities related to layer/model functionality."""
+
+# TODO(b/110718070): Move these functions back to tensorflow/python/keras/utils
+# once __init__ files no longer require all of tf.keras to be imported together.
+
+import collections
+import weakref
+
+from tensorflow.python.util import object_identity
+
+try:
+  # typing module is only used for comment type annotations.
+  import typing  # pylint: disable=g-import-not-at-top, unused-import
+except ImportError:
+  pass
+
+
+def is_layer(obj):
+  """Implicit check for Layer-like objects."""
+  # TODO(b/110718070): Replace with isinstance(obj, base_layer.Layer).
+  return hasattr(obj, "_is_layer") and not isinstance(obj, type)
+
+
+def has_weights(obj):
+  """Implicit check for Layer-like objects."""
+  # TODO(b/110718070): Replace with isinstance(obj, base_layer.Layer).
+  has_weight = (hasattr(type(obj), "trainable_weights")
+                and hasattr(type(obj), "non_trainable_weights"))
+
+  return has_weight and not isinstance(obj, type)
+
+
+class MutationSentinel(object):
+  """Container for tracking whether a property is in a cached state."""
+  _in_cached_state = False
+
+  def mark_as(self, value):  # type: (MutationSentinel, bool) -> bool
+    may_affect_upstream = (value != self._in_cached_state)
+    self._in_cached_state = value
+    return may_affect_upstream
+
+  @property
+  def in_cached_state(self):
+    return self._in_cached_state
+
+
+class AttributeSentinel(object):
+  """Container for managing attribute cache state within a Layer.
+
+  The cache can be invalidated either on an individual basis (for instance when
+  an attribute is mutated) or a layer-wide basis (such as when a new dependency
+  is added).
+  """
+
+  def __init__(self, always_propagate=False):
+    self._parents = weakref.WeakSet()
+    self.attributes = collections.defaultdict(MutationSentinel)
+
+    # The trackable data structure containers are simple pass throughs. They
+    # don't know or care about particular attributes. As a result, they will
+    # consider themselves to be in a cached state, so it's up to the Layer
+    # which contains them to terminate propagation.
+    self.always_propagate = always_propagate
+
+  def __repr__(self):
+    return "{}\n  {}".format(
+        super(AttributeSentinel, self).__repr__(),
+        {k: v.in_cached_state for k, v in self.attributes.items()})
+
+  def add_parent(self, node):
+    # type: (AttributeSentinel, AttributeSentinel) -> None
+
+    # Properly tracking removal is quite challenging; however since this is only
+    # used to invalidate a cache it's alright to be overly conservative. We need
+    # to invalidate the cache of `node` (since it has implicitly gained a child)
+    # but we don't need to invalidate self since attributes should not depend on
+    # parent Layers.
+    self._parents.add(node)
+    node.invalidate_all()
+
+  def get(self, key):
+    # type: (AttributeSentinel, str) -> bool
+    return self.attributes[key].in_cached_state
+
+  def _set(self, key, value):
+    # type: (AttributeSentinel, str, bool) -> None
+    may_affect_upstream = self.attributes[key].mark_as(value)
+    if may_affect_upstream or self.always_propagate:
+      for node in self._parents:  # type: AttributeSentinel
+        node.invalidate(key)
+
+  def mark_cached(self, key):
+    # type: (AttributeSentinel, str) -> None
+    self._set(key, True)
+
+  def invalidate(self, key):
+    # type: (AttributeSentinel, str) -> None
+    self._set(key, False)
+
+  def invalidate_all(self):
+    # Parents may have different keys than their children, so we locally
+    # invalidate but use the `invalidate_all` method of parents.
+    for key in self.attributes.keys():
+      self.attributes[key].mark_as(False)
+
+    for node in self._parents:
+      node.invalidate_all()
+
+
+def filter_empty_layer_containers(layer_list):
+  """Filter out empty Layer-like containers and uniquify."""
+  # TODO(b/130381733): Make this an attribute in base_layer.Layer.
+  existing = object_identity.ObjectIdentitySet()
+  to_visit = layer_list[::-1]
+  while to_visit:
+    obj = to_visit.pop()
+    if obj in existing:
+      continue
+    existing.add(obj)
+    if is_layer(obj):
+      yield obj
+    else:
+      sub_layers = getattr(obj, "layers", None) or []
+
+      # Trackable data structures will not show up in ".layers" lists, but
+      # the layers they contain will.
+      to_visit.extend(sub_layers[::-1])

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/python_state.py

@@ -0,0 +1,87 @@
+"""Utilities for including Python state in TensorFlow checkpoints."""
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import abc
+
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.trackable import base
+from tensorflow.python.util.tf_export import tf_export
+
+
+PYTHON_STATE = "py_state"
+
+
+@tf_export("train.experimental.PythonState")
+class PythonState(base.Trackable, metaclass=abc.ABCMeta):
+  """A mixin for putting Python state in an object-based checkpoint.
+
+  This is an abstract class which allows extensions to TensorFlow's object-based
+  checkpointing (see `tf.train.Checkpoint`). For example a wrapper for NumPy
+  arrays:
+
+  ```python
+  import io
+  import numpy
+
+  class NumpyWrapper(tf.train.experimental.PythonState):
+
+    def __init__(self, array):
+      self.array = array
+
+    def serialize(self):
+      string_file = io.BytesIO()
+      try:
+        numpy.save(string_file, self.array, allow_pickle=False)
+        serialized = string_file.getvalue()
+      finally:
+        string_file.close()
+      return serialized
+
+    def deserialize(self, string_value):
+      string_file = io.BytesIO(string_value)
+      try:
+        self.array = numpy.load(string_file, allow_pickle=False)
+      finally:
+        string_file.close()
+  ```
+
+  Instances of `NumpyWrapper` are checkpointable objects, and will be saved and
+  restored from checkpoints along with TensorFlow state like variables.
+
+  ```python
+  root = tf.train.Checkpoint(numpy=NumpyWrapper(numpy.array([1.])))
+  save_path = root.save(prefix)
+  root.numpy.array *= 2.
+  assert [2.] == root.numpy.array
+  root.restore(save_path)
+  assert [1.] == root.numpy.array
+  ```
+  """
+
+  @abc.abstractmethod
+  def serialize(self):
+    """Callback to serialize the object. Returns a string."""
+
+  @abc.abstractmethod
+  def deserialize(self, string_value):
+    """Callback to deserialize the object."""
+
+  def _serialize_to_tensors(self):
+    """Implements Trackable._serialize_to_tensors."""
+    with ops.init_scope():
+      value = constant_op.constant(self.serialize(), dtype=dtypes.string)
+    return {PYTHON_STATE: value}

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/resource.py

@@ -0,0 +1,308 @@
+# 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.
+# ==============================================================================
+"""Definitions for resource-type trackable object classes."""
+
+import contextlib
+import copy
+import weakref
+
+from tensorflow.python.eager import context
+from tensorflow.python.eager import def_function
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.trackable import base
+from tensorflow.python.util import tf_contextlib
+from tensorflow.python.util.tf_export import tf_export
+
+# global _RESOURCE_TRACKER_STACK
+_RESOURCE_TRACKER_STACK = []
+
+
+class ResourceTracker:
+  """An object that tracks a list of resources."""
+
+  __slots__ = ["_resources"]
+
+  def __init__(self):
+    self._resources = []
+
+  @property
+  def resources(self):
+    return self._resources
+
+  def add_resource(self, resource):
+    self._resources.append(resource)
+
+
+@tf_contextlib.contextmanager
+def resource_tracker_scope(resource_tracker):
+  """A context to manage resource trackers.
+
+  Use this in order to collect up all resources created within a block of code.
+  Example usage:
+
+  ```python
+  resource_tracker = ResourceTracker()
+  with resource_tracker_scope(resource_tracker):
+    resource = TrackableResource()
+
+  assert resource_tracker.resources == [resource]
+
+  Args:
+    resource_tracker: The passed in ResourceTracker object
+
+  Yields:
+    A scope in which the resource_tracker is active.
+  """
+  global _RESOURCE_TRACKER_STACK
+  old = list(_RESOURCE_TRACKER_STACK)
+  _RESOURCE_TRACKER_STACK.append(resource_tracker)
+  try:
+    yield
+  finally:
+    _RESOURCE_TRACKER_STACK = old
+
+
+def _make_getter(captured_getter, captured_previous):
+  """To avoid capturing loop variables."""
+
+  def getter(*args, **kwargs):
+    return captured_getter(captured_previous, *args, **kwargs)
+
+  return getter
+
+
+class _ResourceMetaclass(type):
+  """Metaclass for CapturableResource."""
+
+  def __call__(cls, *args, **kwargs):
+
+    def default_resource_creator(next_creator, *a, **kw):
+      assert next_creator is None
+      obj = cls.__new__(cls, *a, **kw)
+      obj.__init__(*a, **kw)
+      return obj
+
+    previous_getter = lambda *a, **kw: default_resource_creator(None, *a, **kw)
+    resource_creator_stack = ops.get_default_graph()._resource_creator_stack
+    for getter in resource_creator_stack[cls._resource_type()]:
+      previous_getter = _make_getter(getter, previous_getter)
+
+    return previous_getter(*args, **kwargs)
+
+
+class CapturableResource(base.Trackable, metaclass=_ResourceMetaclass):
+  """Holds a Tensor which a tf.function can capture.
+
+  `CapturableResource`s are discovered by traversing the graph of object
+  attributes, e.g. during `tf.saved_model.save`. They are excluded from the
+  scope-based tracking of `TrackableResource`; generally things that require
+  initialization should inherit from `TrackableResource` instead of
+  `CapturableResource` directly.
+  """
+
+  def __init__(self, device=""):
+    """Initialize the `CapturableResource`.
+
+    Args:
+      device: A string indicating a required placement for this resource,
+        e.g. "CPU" if this resource must be created on a CPU device. A blank
+        device allows the user to place resource creation, so generally this
+        should be blank unless the resource only makes sense on one device.
+    """
+    self._resource_handle_value = None
+    self._resource_device = device
+    self._self_destruction_context = (
+        context.eager_mode if context.executing_eagerly()
+        else ops.get_default_graph().as_default)
+
+  @classmethod
+  def _resource_type(cls):
+    return cls.__name__
+
+  @property
+  def _destruction_context(self):
+    return getattr(self, "_self_destruction_context",
+                   # no-op context
+                   contextlib.suppress)
+
+  @_destruction_context.setter
+  def _destruction_context(self, destruction_context):
+    self._self_destruction_context = destruction_context
+
+  def _create_resource(self):
+    """A function that creates a resource handle."""
+    raise NotImplementedError("TrackableResource._create_resource not "
+                              "implemented.")
+
+  @property
+  def _resource_handle(self):
+    return self._resource_handle_value
+
+  @_resource_handle.setter
+  def _resource_handle(self, value):
+    if isinstance(value, (tensor.Tensor, ops.EagerTensor)):
+      value._parent_trackable = weakref.ref(self)  # pylint: disable=protected-access
+    self._resource_handle_value = value
+
+  def _initialize(self):
+    """A function that initializes the resource. Optional."""
+    pass
+
+  def _destroy_resource(self):
+    """A function that destroys the resource. Optional."""
+    pass
+
+  @property
+  def resource_handle(self):
+    """Returns the resource handle associated with this Resource."""
+    if self._resource_handle is None:
+      with ops.device(self._resource_device):
+        self._resource_handle = self._create_resource()
+    return self._resource_handle
+
+  def _export_to_saved_model_graph(
+      self, object_map, tensor_map, **unused_kwargs):
+    """For implementing `Trackable`."""
+    new_obj = copy.copy(self)
+    # pylint: disable=protected-access
+    with ops.device(self._resource_device):
+      new_resource = new_obj._create_resource()
+    new_obj._resource_handle = new_resource
+    # pylint: enable=protected-access
+    object_map[self] = new_obj
+    tensor_map[self.resource_handle] = new_resource
+    return [self.resource_handle]
+
+  def _trackable_children(self, save_type=base.SaveType.CHECKPOINT, **kwargs):
+    children = super()._trackable_children(save_type, **kwargs)
+    if save_type == "savedmodel":
+      @def_function.function(input_signature=[], autograph=False)
+      def _creator():
+        resource = self._create_resource()
+        return resource
+
+      @def_function.function(input_signature=[], autograph=False)
+      def _initializer():
+        self._initialize()
+        return 1  # Dummy return
+
+      @def_function.function(input_signature=[], autograph=False)
+      def _destroyer():
+        self._destroy_resource()
+        return 1  # Dummy return
+
+      children.update({
+          "_create_resource": _creator,
+          "_initialize": _initializer,
+          "_destroy_resource": _destroyer,
+      })
+    return children
+
+  def __del__(self):
+    try:
+      # Outer race condition: on program exit, the destruction context may be
+      # deleted before this __del__ is called. At this point we can safely
+      # exit without calling _destroy_resource() and let Python handle things.
+      with self._destruction_context():
+        # Inner race condition: possible between this and `ScopedTFFunction`
+        # whereby if an entire garbage collection chain containing both
+        # objects is moved to unreachable during the same garbage collection
+        # cycle, the __del__ for `ScopedTFFunction` can be collected before
+        # this method is called. In that case, we can't do much but
+        # continue.
+        self._destroy_resource()
+    except Exception:  # pylint: disable=broad-except
+      # Silence all error logs that occur when attempting to destroy this
+      # resource.
+      pass
+
+
+@tf_export("saved_model.experimental.TrackableResource")
+class TrackableResource(CapturableResource):
+  """Holds a Tensor which a tf.function can capture.
+
+  A TrackableResource is most useful for stateful Tensors that require
+  initialization, such as `tf.lookup.StaticHashTable`. `TrackableResource`s
+  are discovered by traversing the graph of object attributes, e.g. during
+  `tf.saved_model.save`.
+
+  A TrackableResource has three methods to override:
+
+  * `_create_resource` should create the resource tensor handle.
+  * `_initialize` should initialize the resource held at `self.resource_handle`.
+  * `_destroy_resource` is called upon a `TrackableResource`'s destruction
+    and should decrement the resource's ref count. For most resources, this
+    should be done with a call to `tf.raw_ops.DestroyResourceOp`.
+
+  Example usage:
+
+  >>> class DemoResource(tf.saved_model.experimental.TrackableResource):
+  ...   def __init__(self):
+  ...     super().__init__()
+  ...     self._initialize()
+  ...   def _create_resource(self):
+  ...     return tf.raw_ops.VarHandleOp(dtype=tf.float32, shape=[2])
+  ...   def _initialize(self):
+  ...     tf.raw_ops.AssignVariableOp(
+  ...         resource=self.resource_handle, value=tf.ones([2]))
+  ...   def _destroy_resource(self):
+  ...     tf.raw_ops.DestroyResourceOp(resource=self.resource_handle)
+  >>> class DemoModule(tf.Module):
+  ...   def __init__(self):
+  ...     self.resource = DemoResource()
+  ...   def increment(self, tensor):
+  ...     return tensor + tf.raw_ops.ReadVariableOp(
+  ...         resource=self.resource.resource_handle, dtype=tf.float32)
+  >>> demo = DemoModule()
+  >>> demo.increment([5, 1])
+  <tf.Tensor: shape=(2,), dtype=float32, numpy=array([6., 2.], dtype=float32)>
+  """
+
+  def __init__(self, device=""):
+    """Initialize the `TrackableResource`.
+
+    Args:
+      device: A string indicating a required placement for this resource,
+        e.g. "CPU" if this resource must be created on a CPU device. A blank
+        device allows the user to place resource creation, so generally this
+        should be blank unless the resource only makes sense on one device.
+    """
+    global _RESOURCE_TRACKER_STACK
+    for resource_tracker in _RESOURCE_TRACKER_STACK:
+      resource_tracker.add_resource(self)
+    super().__init__(device=device)
+
+
+# TODO(b/124205571,b/124092991): Solve destruction of resources.
+class RestoredResource(TrackableResource):
+  """Restored SavedResource."""
+
+  def __init__(self, device=""):
+    super().__init__(device=device)
+
+  @classmethod
+  def _deserialize_from_proto(cls, object_proto, dependencies, **unused_kwargs):
+    obj = cls(device=object_proto.resource.device)
+    resource_creator = dependencies.get("_create_resource")
+    if resource_creator is not None:
+      obj._create_resource = resource_creator  # pylint: disable=protected-access
+    return obj
+
+  def _add_trackable_child(self, name, value):
+    setattr(self, name, value)
+    if (isinstance(value, base.Trackable) and
+        not isinstance(value, def_function.Function)):
+      self._track_trackable(value, name)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/trackable/trackable_utils.py

@@ -0,0 +1,178 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utility methods for the trackable dependencies."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+
+
+def pretty_print_node_path(path):
+  if not path:
+    return "root object"
+  else:
+    return "root." + ".".join([p.name for p in path])
+
+
+class CyclicDependencyError(Exception):
+
+  def __init__(self, leftover_dependency_map):
+    """Creates a CyclicDependencyException."""
+    # Leftover edges that were not able to be topologically sorted.
+    self.leftover_dependency_map = leftover_dependency_map
+    super(CyclicDependencyError, self).__init__()
+
+
+def order_by_dependency(dependency_map):
+  """Topologically sorts the keys of a map so that dependencies appear first.
+
+  Uses Kahn's algorithm:
+  https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm
+
+  Args:
+    dependency_map: a dict mapping values to a list of dependencies (other keys
+      in the map). All keys and dependencies must be hashable types.
+
+  Returns:
+    A sorted array of keys from dependency_map.
+
+  Raises:
+    CyclicDependencyError: if there is a cycle in the graph.
+    ValueError: If there are values in the dependency map that are not keys in
+      the map.
+  """
+  # Maps trackables -> trackables that depend on them. These are the edges used
+  # in Kahn's algorithm.
+  reverse_dependency_map = collections.defaultdict(set)
+  for x, deps in dependency_map.items():
+    for dep in deps:
+      reverse_dependency_map[dep].add(x)
+
+  # Validate that all values in the dependency map are also keys.
+  unknown_keys = reverse_dependency_map.keys() - dependency_map.keys()
+  if unknown_keys:
+    raise ValueError("Found values in the dependency map which are not keys: "
+                     f"{unknown_keys}")
+
+  # Generate the list sorted by objects without dependencies -> dependencies.
+  # The returned list will reverse this.
+  reversed_dependency_arr = []
+
+  # Prefill `to_visit` with all nodes that do not have other objects depending
+  # on them.
+  to_visit = [x for x in dependency_map if x not in reverse_dependency_map]
+
+  while to_visit:
+    x = to_visit.pop(0)
+    reversed_dependency_arr.append(x)
+    for dep in set(dependency_map[x]):
+      edges = reverse_dependency_map[dep]
+      edges.remove(x)
+      if not edges:
+        to_visit.append(dep)
+        reverse_dependency_map.pop(dep)
+
+  if reverse_dependency_map:
+    leftover_dependency_map = collections.defaultdict(list)
+    for dep, xs in reverse_dependency_map.items():
+      for x in xs:
+        leftover_dependency_map[x].append(dep)
+    raise CyclicDependencyError(leftover_dependency_map)
+
+  return reversed(reversed_dependency_arr)
+
+
+_ESCAPE_CHAR = "."  # For avoiding conflicts with user-specified names.
+
+# Keyword for identifying that the next bit of a checkpoint variable name is a
+# slot name. Checkpoint names for slot variables look like:
+#
+#   <path to variable>/<_OPTIMIZER_SLOTS_NAME>/<path to optimizer>/<slot name>
+#
+# Where <path to variable> is a full path from the checkpoint root to the
+# variable being slotted for.
+_OPTIMIZER_SLOTS_NAME = _ESCAPE_CHAR + "OPTIMIZER_SLOT"
+# Keyword for separating the path to an object from the name of an
+# attribute in checkpoint names. Used like:
+#   <path to variable>/<_OBJECT_ATTRIBUTES_NAME>/<name of attribute>
+OBJECT_ATTRIBUTES_NAME = _ESCAPE_CHAR + "ATTRIBUTES"
+
+# A constant string that is used to reference the save and restore functions of
+#  Trackable objects that define `_serialize_to_tensors` and
+# `_restore_from_tensors`. This is written as the key in the
+# `SavedObject.saveable_objects<string, SaveableObject>` map in the SavedModel.
+SERIALIZE_TO_TENSORS_NAME = _ESCAPE_CHAR + "TENSORS"
+
+
+def escape_local_name(name):
+  # We need to support slashes in local names for compatibility, since this
+  # naming scheme is being patched in to things like Layer.add_variable where
+  # slashes were previously accepted. We also want to use slashes to indicate
+  # edges traversed to reach the variable, so we escape forward slashes in
+  # names.
+  return (name.replace(_ESCAPE_CHAR, _ESCAPE_CHAR + _ESCAPE_CHAR).replace(
+      r"/", _ESCAPE_CHAR + "S"))
+
+
+def object_path_to_string(node_path_arr):
+  """Converts a list of nodes to a string."""
+  return "/".join(
+      (escape_local_name(trackable.name) for trackable in node_path_arr))
+
+
+def checkpoint_key(object_path, local_name):
+  """Returns the checkpoint key for a local attribute of an object."""
+  key_suffix = escape_local_name(local_name)
+  if local_name == SERIALIZE_TO_TENSORS_NAME:
+    # In the case that Trackable uses the _serialize_to_tensor API for defining
+    # tensors to save to the checkpoint, the suffix should be the key(s)
+    # returned by `_serialize_to_tensor`. The suffix used here is empty.
+    key_suffix = ""
+
+  return f"{object_path}/{OBJECT_ATTRIBUTES_NAME}/{key_suffix}"
+
+
+def extract_object_name(key):
+  """Substrings the checkpoint key to the start of "/.ATTRIBUTES"."""
+  search_key = "/" + OBJECT_ATTRIBUTES_NAME
+  return key[:key.index(search_key)]
+
+
+def extract_local_name(key, prefix=None):
+  """Returns the substring after the "/.ATTIBUTES/" in the checkpoint key."""
+  # "local name" refers to the the keys of `Trackable._serialize_to_tensors.`
+  prefix = prefix or ""
+  search_key = OBJECT_ATTRIBUTES_NAME + "/" + prefix
+  # If checkpoint is saved from TF1, return key as is.
+  try:
+    return key[key.index(search_key) + len(search_key):]
+  except ValueError:
+    return key
+
+
+def slot_variable_key(variable_path, optimizer_path, slot_name):
+  """Returns checkpoint key for a slot variable."""
+  # Name slot variables:
+  #
+  #   <variable name>/<_OPTIMIZER_SLOTS_NAME>/<optimizer path>/<slot name>
+  #
+  # where <variable name> is exactly the checkpoint name used for the original
+  # variable, including the path from the checkpoint root and the local name in
+  # the object which owns it. Note that we only save slot variables if the
+  # variable it's slotting for is also being saved.
+
+  return (f"{variable_path}/{_OPTIMIZER_SLOTS_NAME}/{optimizer_path}/"
+          f"{escape_local_name(slot_name)}")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/adadelta.py

@@ -0,0 +1,198 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Adadelta for TensorFlow."""
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.training import training_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["train.AdadeltaOptimizer"])
+class AdadeltaOptimizer(optimizer.Optimizer):
+  """Optimizer that implements the Adadelta algorithm.
+
+  References:
+    ADADELTA - An Adaptive Learning Rate Method:
+      [Zeiler, 2012](http://arxiv.org/abs/1212.5701)
+      ([pdf](http://arxiv.org/pdf/1212.5701v1.pdf))
+
+  @compatibility(TF2)
+  tf.compat.v1.train.AdadeltaOptimizer is compatible with eager mode and
+  `tf.function`.
+  When eager execution is enabled, `learning_rate`, `rho`,
+  and `epsilon` can each be a callable that
+  takes no arguments and returns the actual value to use. This can be useful
+  for changing these values across different invocations of optimizer
+  functions.
+
+  To switch to native TF2 style, use [`tf.keras.optimizers.Adadelta`]
+  (https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adadelta)
+  instead. Please notice that due to the implementation differences,
+  `tf.keras.optimizers.Adadelta` and
+  `tf.compat.v1.train.AdadeltaOptimizer` may have slight differences in
+  floating point numerics even though the formula used for the variable
+  updates still matches.
+
+  #### Structural mapping to native TF2
+
+  Before:
+
+  ```python
+  optimizer = tf.compat.v1.train.AdadeltaOptimizer(
+    learning_rate=learning_rate,
+    rho=rho,
+    epsilon=epsilon)
+  ```
+
+  After:
+
+  ```python
+  optimizer = tf.keras.optimizers.Adadelta(
+    learning_rate=learning_rate,
+    rho=rho,
+    epsilon=epsilon)
+  ```
+
+  #### How to map arguments
+  | TF1 Arg Name       | TF2 Arg Name   | Note                             |
+  | ------------------ | -------------  | -------------------------------  |
+  | `learning_rate`    | `learning_rate`| Be careful of setting           |
+  : : : learning_rate tensor value computed from the global step.          :
+  : : : In TF1 this was usually meant to imply a dynamic learning rate and :
+  : : : would recompute in each step. In TF2 (eager + function) it will    :
+  : : : treat it as a scalar value that only gets computed once instead of :
+  : : : a symbolic placeholder to be computed each time.                   :
+  | `rho`              | `rho`          | -                                |
+  | `epsilon`          | `epsilon`      | Default value is 1e-08 in TF1,   |
+  :                    :                : but 1e-07 in TF2.                :
+  | `use_locking`      | -              | Not applicable in TF2.           |
+
+  #### Before & after usage example
+  Before:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.compat.v1.train.AdadeltaOptimizer(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  After:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.keras.optimizers.Adadelta(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  @end_compatibility
+  """
+
+  def __init__(self, learning_rate=0.001, rho=0.95, epsilon=1e-8,
+               use_locking=False, name="Adadelta"):
+    """Construct a new Adadelta optimizer.
+
+    Args:
+      learning_rate: A `Tensor` or a floating point value. The learning rate.
+        To match the exact form in the original paper use 1.0.
+      rho: A `Tensor` or a floating point value. The decay rate.
+      epsilon: A `Tensor` or a floating point value.  A constant epsilon used
+               to better conditioning the grad update.
+      use_locking: If `True` use locks for update operations.
+      name: Optional name prefix for the operations created when applying
+        gradients.  Defaults to "Adadelta".
+
+
+    """
+    super(AdadeltaOptimizer, self).__init__(use_locking, name)
+    self._lr = learning_rate
+    self._rho = rho
+    self._epsilon = epsilon
+
+    # Tensor versions of the constructor arguments, created in _prepare().
+    self._lr_t = None
+    self._rho_t = None
+    self._epsilon_t = None
+
+  def _create_slots(self, var_list):
+    for v in var_list:
+      self._zeros_slot(v, "accum", self._name)
+      self._zeros_slot(v, "accum_update", self._name)
+
+  def _prepare(self):
+    lr = self._call_if_callable(self._lr)
+    rho = self._call_if_callable(self._rho)
+    epsilon = self._call_if_callable(self._epsilon)
+
+    self._lr_t = ops.convert_to_tensor(lr, name="lr")
+    self._rho_t = ops.convert_to_tensor(rho, name="rho")
+    self._epsilon_t = ops.convert_to_tensor(epsilon, name="epsilon")
+
+  def _apply_dense(self, grad, var):
+    accum = self.get_slot(var, "accum")
+    accum_update = self.get_slot(var, "accum_update")
+    return training_ops.apply_adadelta(
+        var,
+        accum,
+        accum_update,
+        math_ops.cast(self._lr_t, var.dtype.base_dtype),
+        math_ops.cast(self._rho_t, var.dtype.base_dtype),
+        math_ops.cast(self._epsilon_t, var.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking)
+
+  def _resource_apply_dense(self, grad, var):
+    accum = self.get_slot(var, "accum")
+    accum_update = self.get_slot(var, "accum_update")
+    return training_ops.resource_apply_adadelta(
+        var.handle,
+        accum.handle,
+        accum_update.handle,
+        math_ops.cast(self._lr_t, grad.dtype.base_dtype),
+        math_ops.cast(self._rho_t, grad.dtype.base_dtype),
+        math_ops.cast(self._epsilon_t, grad.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking)
+
+  def _apply_sparse(self, grad, var):
+    accum = self.get_slot(var, "accum")
+    accum_update = self.get_slot(var, "accum_update")
+    return training_ops.sparse_apply_adadelta(
+        var,
+        accum,
+        accum_update,
+        math_ops.cast(self._lr_t, var.dtype.base_dtype),
+        math_ops.cast(self._rho_t, var.dtype.base_dtype),
+        math_ops.cast(self._epsilon_t, var.dtype.base_dtype),
+        grad.values,
+        grad.indices,
+        use_locking=self._use_locking)
+
+  def _resource_apply_sparse(self, grad, var, indices):
+    accum = self.get_slot(var, "accum")
+    accum_update = self.get_slot(var, "accum_update")
+    return training_ops.resource_sparse_apply_adadelta(
+        var.handle,
+        accum.handle,
+        accum_update.handle,
+        math_ops.cast(self._lr_t, grad.dtype),
+        math_ops.cast(self._rho_t, grad.dtype),
+        math_ops.cast(self._epsilon_t, grad.dtype),
+        grad,
+        indices,
+        use_locking=self._use_locking)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/adagrad.py

@@ -0,0 +1,195 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Adagrad for TensorFlow."""
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import gen_array_ops
+from tensorflow.python.ops import init_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.training import training_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["train.AdagradOptimizer"])
+class AdagradOptimizer(optimizer.Optimizer):
+  """Optimizer that implements the Adagrad algorithm.
+
+  References:
+    Adaptive Subgradient Methods for Online Learning and Stochastic Optimization
+      :[Duchi et al., 2011](http://jmlr.org/papers/v12/duchi11a.html)
+      ([pdf](http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf))
+
+  @compatibility(TF2)
+  tf.compat.v1.train.AdagradOptimizer is compatible with eager mode and
+  `tf.function`.
+  When eager execution is enabled, `learning_rate`,
+  `initial_accumulator_value`, and `epsilon` can each be a callable that
+  takes no arguments and returns the actual value to use. This can be useful
+  for changing these values across different invocations of optimizer
+  functions.
+
+  To switch to native TF2 style, use [`tf.keras.optimizers.Adagrad`]
+  (https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adagrad)
+  instead. Please notice that due to the implementation differences,
+  `tf.keras.optimizers.Adagrad` and
+  `tf.compat.v1.train.AdagradOptimizer` may have slight differences in
+  floating point numerics even though the formula used for the variable
+  updates still matches.
+
+  #### Structural mapping to native TF2
+
+  Before:
+
+  ```python
+  optimizer = tf.compat.v1.train.AdagradOptimizer(
+    learning_rate=learning_rate,
+    initial_accumulator_value=initial_accumulator_value)
+  ```
+
+  After:
+
+  ```python
+  optimizer = tf.keras.optimizers.Adagrad(
+    learning_rate=learning_rate,
+    initial_accumulator_value=initial_accumulator_value,
+    epsilon=1e-07)
+  ```
+
+  #### How to map arguments
+  | TF1 Arg Name       | TF2 Arg Name   | Note                             |
+  | ------------------ | -------------  | -------------------------------  |
+  | `learning_rate`    | `learning_rate` | Be careful of setting           |
+  : : : learning_rate tensor value computed from the global step.          :
+  : : : In TF1 this was usually meant to imply a dynamic learning rate and :
+  : : : would recompute in each step. In TF2 (eager + function) it will    :
+  : : : treat it as a scalar value that only gets computed once instead of :
+  : : : a symbolic placeholder to be computed each time.                   :
+  | `initial_accumulator_value` | `initial_accumulator_value` | The        |
+  : : : argument can be value of zero in TF2, which is not accepted in TF1.|
+  | - | `epsilon`      | `epsilon` is become configurable in TF2. The      |
+  : : : defualt value is changed from 1e-8 to 1e-7                         :
+  | `use_locking`      | -             | Not applicable in TF2.            |
+
+  #### Before & after usage example
+  Before:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.compat.v1.train.AdagradOptimizer(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  After:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.keras.optimizers.Adagrad(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  @end_compatibility
+  """
+
+  def __init__(self, learning_rate, initial_accumulator_value=0.1,
+               use_locking=False, name="Adagrad"):
+    """Construct a new Adagrad optimizer.
+
+    Args:
+      learning_rate: A `Tensor` or a floating point value.  The learning rate.
+      initial_accumulator_value: A floating point value.
+        Starting value for the accumulators, must be positive.
+      use_locking: If `True` use locks for update operations.
+      name: Optional name prefix for the operations created when applying
+        gradients.  Defaults to "Adagrad".
+
+    Raises:
+      ValueError: If the `initial_accumulator_value` is invalid.
+
+    """
+    if initial_accumulator_value <= 0.0:
+      raise ValueError("initial_accumulator_value must be positive: %s" %
+                       initial_accumulator_value)
+    super(AdagradOptimizer, self).__init__(use_locking, name)
+    self._learning_rate = learning_rate
+    self._initial_accumulator_value = initial_accumulator_value
+    # Created in Initialize.
+    self._learning_rate_tensor = None
+
+  def _create_slots(self, var_list):
+    for v in var_list:
+      dtype = v.dtype.base_dtype
+      if v.get_shape().is_fully_defined():
+        init = init_ops.constant_initializer(self._initial_accumulator_value,
+                                             dtype=dtype)
+      else:
+        init = self._init_constant_op(v, dtype)
+      self._get_or_make_slot_with_initializer(v, init, v.get_shape(), dtype,
+                                              "accumulator", self._name)
+
+  def _init_constant_op(self, v, dtype):
+    def init():
+      # Use a Tensor instead of initializer if variable does not have
+      # static shape.
+      init_constant = gen_array_ops.fill(array_ops.shape(v),
+                                         self._initial_accumulator_value)
+      return math_ops.cast(init_constant, dtype)
+    return init
+
+  def _prepare(self):
+    learning_rate = self._call_if_callable(self._learning_rate)
+    self._learning_rate_tensor = ops.convert_to_tensor(
+        learning_rate, name="learning_rate")
+
+  def _apply_dense(self, grad, var):
+    acc = self.get_slot(var, "accumulator")
+    return training_ops.apply_adagrad(
+        var,
+        acc,
+        math_ops.cast(self._learning_rate_tensor, var.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking)
+
+  def _resource_apply_dense(self, grad, var):
+    acc = self.get_slot(var, "accumulator")
+    return training_ops.resource_apply_adagrad(
+        var.handle,
+        acc.handle,
+        math_ops.cast(self._learning_rate_tensor, grad.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking)
+
+  def _apply_sparse(self, grad, var):
+    acc = self.get_slot(var, "accumulator")
+    return training_ops.sparse_apply_adagrad(
+        var,
+        acc,
+        math_ops.cast(self._learning_rate_tensor, var.dtype.base_dtype),
+        grad.values,
+        grad.indices,
+        use_locking=self._use_locking)
+
+  def _resource_apply_sparse(self, grad, var, indices):
+    acc = self.get_slot(var, "accumulator")
+    return training_ops.resource_sparse_apply_adagrad(
+        var.handle,
+        acc.handle,
+        math_ops.cast(self._learning_rate_tensor, grad.dtype),
+        grad,
+        indices,
+        use_locking=self._use_locking)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/adagrad_da.py

@@ -0,0 +1,171 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Adagrad Dual Averaging for TensorFlow."""
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.training import training_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["train.AdagradDAOptimizer"])
+class AdagradDAOptimizer(optimizer.Optimizer):
+  """Adagrad Dual Averaging algorithm for sparse linear models.
+
+  This optimizer takes care of regularization of unseen features in a mini batch
+  by updating them when they are seen with a closed form update rule that is
+  equivalent to having updated them on every mini-batch.
+
+  AdagradDA is typically used when there is a need for large sparsity in the
+  trained model. This optimizer only guarantees sparsity for linear models. Be
+  careful when using AdagradDA for deep networks as it will require careful
+  initialization of the gradient accumulators for it to train.
+
+  References:
+    Adaptive Subgradient Methods for Online Learning and Stochastic Optimization
+      :[Duchi et al., 2011](http://jmlr.org/papers/v12/duchi11a.html)
+      ([pdf](http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf))
+  """
+
+  def __init__(self,
+               learning_rate,
+               global_step,
+               initial_gradient_squared_accumulator_value=0.1,
+               l1_regularization_strength=0.0,
+               l2_regularization_strength=0.0,
+               use_locking=False,
+               name="AdagradDA"):
+    """Construct a new AdagradDA optimizer.
+
+    Args:
+      learning_rate: A `Tensor` or a floating point value.  The learning rate.
+      global_step: A `Tensor` containing the current training step number.
+      initial_gradient_squared_accumulator_value: A floating point value.
+        Starting value for the accumulators, must be positive.
+      l1_regularization_strength: A float value, must be greater than or
+        equal to zero.
+      l2_regularization_strength: A float value, must be greater than or
+        equal to zero.
+      use_locking: If `True` use locks for update operations.
+      name: Optional name prefix for the operations created when applying
+        gradients.  Defaults to "AdagradDA".
+
+    Raises:
+      ValueError: If the `initial_gradient_squared_accumulator_value` is
+      invalid.
+    """
+    if initial_gradient_squared_accumulator_value <= 0.0:
+      raise ValueError("initial_gradient_squared_accumulator_value must be "
+                       "positive: %s" %
+                       initial_gradient_squared_accumulator_value)
+    super(AdagradDAOptimizer, self).__init__(use_locking, name)
+    self._learning_rate = learning_rate
+    self._initial_gradient_squared_accumulator_value = (
+        initial_gradient_squared_accumulator_value)
+    # Created in Initialize.
+    self._learning_rate_tensor = None
+    self._l1_regularization_strength = l1_regularization_strength
+    self._l2_regularization_strength = l2_regularization_strength
+    self._global_step = global_step
+    self._global_step_on_worker = None
+
+  def _create_slots(self, var_list):
+    for v in var_list:
+      with ops.colocate_with(v):
+        g_val = constant_op.constant(
+            0.0, shape=v.get_shape(), dtype=v.dtype.base_dtype)
+        gg_val = constant_op.constant(
+            self._initial_gradient_squared_accumulator_value,
+            shape=v.get_shape(),
+            dtype=v.dtype.base_dtype)
+      self._get_or_make_slot(v, g_val, "gradient_accumulator", self._name)
+      self._get_or_make_slot(v, gg_val, "gradient_squared_accumulator",
+                             self._name)
+
+  def _prepare(self):
+    self._learning_rate_tensor = ops.convert_to_tensor(
+        self._learning_rate, name="learning_rate")
+    # Performance optimization so that worker creates a copy of the global step
+    # to avoid overloading the parameter server holding the global step.
+    with ops.colocate_with(self._learning_rate_tensor):
+      self._global_step_on_worker = array_ops.identity(self._global_step) + 1
+
+  def _apply_dense(self, grad, var):
+    g_acc = self.get_slot(var, "gradient_accumulator")
+    gg_acc = self.get_slot(var, "gradient_squared_accumulator")
+    with ops.device(var.device):
+      global_step = array_ops.identity(self._global_step_on_worker)
+    return training_ops.apply_adagrad_da(
+        var,
+        g_acc,
+        gg_acc,
+        grad,
+        math_ops.cast(self._learning_rate_tensor, var.dtype.base_dtype),
+        math_ops.cast(self._l1_regularization_strength, var.dtype.base_dtype),
+        math_ops.cast(self._l2_regularization_strength, var.dtype.base_dtype),
+        global_step,
+        use_locking=self._use_locking)
+
+  def _resource_apply_dense(self, grad, var):
+    g_acc = self.get_slot(var, "gradient_accumulator")
+    gg_acc = self.get_slot(var, "gradient_squared_accumulator")
+    with ops.device(var.device):
+      global_step = array_ops.identity(self._global_step_on_worker)
+    return training_ops.resource_apply_adagrad_da(
+        var.handle,
+        g_acc.handle,
+        gg_acc.handle,
+        grad,
+        math_ops.cast(self._learning_rate_tensor, grad.dtype.base_dtype),
+        math_ops.cast(self._l1_regularization_strength, grad.dtype.base_dtype),
+        math_ops.cast(self._l2_regularization_strength, grad.dtype.base_dtype),
+        global_step,
+        use_locking=self._use_locking)
+
+  def _apply_sparse(self, grad, var):
+    g_acc = self.get_slot(var, "gradient_accumulator")
+    gg_acc = self.get_slot(var, "gradient_squared_accumulator")
+    with ops.device(var.device):
+      global_step = array_ops.identity(self._global_step_on_worker)
+    return training_ops.sparse_apply_adagrad_da(
+        var,
+        g_acc,
+        gg_acc,
+        grad.values,
+        grad.indices,
+        math_ops.cast(self._learning_rate_tensor, var.dtype.base_dtype),
+        math_ops.cast(self._l1_regularization_strength, var.dtype.base_dtype),
+        math_ops.cast(self._l2_regularization_strength, var.dtype.base_dtype),
+        global_step,
+        use_locking=self._use_locking)
+
+  def _resource_apply_sparse(self, grad, var, indices):
+    g_acc = self.get_slot(var, "gradient_accumulator")
+    gg_acc = self.get_slot(var, "gradient_squared_accumulator")
+    with ops.device(var.device):
+      global_step = array_ops.identity(self._global_step_on_worker)
+    return training_ops.resource_sparse_apply_adagrad_da(
+        var.handle,
+        g_acc.handle,
+        gg_acc.handle,
+        grad,
+        indices,
+        math_ops.cast(self._learning_rate_tensor, grad.dtype),
+        math_ops.cast(self._l1_regularization_strength, grad.dtype),
+        math_ops.cast(self._l2_regularization_strength, grad.dtype),
+        global_step,
+        use_locking=self._use_locking)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/adam.py

@@ -0,0 +1,303 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Adam for TensorFlow."""
+from tensorflow.python.eager import context
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.ops import state_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.training import training_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["train.AdamOptimizer"])
+class AdamOptimizer(optimizer.Optimizer):
+  """Optimizer that implements the Adam algorithm.
+
+  References:
+    Adam - A Method for Stochastic Optimization:
+      [Kingma et al., 2015](https://arxiv.org/abs/1412.6980)
+      ([pdf](https://arxiv.org/pdf/1412.6980.pdf))
+
+  @compatibility(TF2)
+  tf.compat.v1.train.AdamOptimizer is compatible with eager mode and
+  `tf.function`.
+  When eager execution is enabled, `learning_rate`, `beta1`, `beta2`, and
+  `epsilon` can each be a callable that takes no arguments and returns the
+  actual value to use. This can be useful for changing these values across
+  different invocations of optimizer functions.
+
+  To switch to native TF2 style, use [`tf.keras.optimizers.Adam`]
+  (https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam)
+  instead. Please notice that due to the implementation differences,
+  `tf.keras.optimizers.Adam` and
+  `tf.compat.v1.train.AdamOptimizer` may have slight differences in
+  floating point numerics even though the formula used for the variable
+  updates still matches.
+
+  #### Structural Mapping to Native TF2
+
+  Before:
+
+  ```python
+  optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)
+  ```
+
+  After:
+
+  ```python
+  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
+  ```
+
+  #### How to Map Arguments
+  |TF1 Arg Name          |TF2 Arg Name |Note                  |
+  |----------------------|-------------|----------------------|
+  |learning_rate         |learning_rate|Be careful of setting learning_rate as a
+  :                      :             : tensor value computed from the global
+  :                      :             : step. In TF1 this was usually meant to
+  :                      :             : imply a dynamic learning rate and would
+  :                      :             : recompute in each step. In TF2 (eager +
+  :                      :             : function) it will treat it as a scalar
+  :                      :             : value that only gets computed once
+  :                      :             : instead of a symbolic placeholder to be
+  :                      :             : computed each time.                   :
+  |beta1                 |beta_1        |                      |
+  |beta2                 |beta_2        |                      |
+  |epsilon               |epsilon      | Default value is 1e-08 in TF1, but
+  :                      :             : 1e-07 in TF2.                     :
+  |use_locking           |N/A          |Not applicable in TF2. |
+
+  #### Before & After Usage Example
+  Before:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  After:
+
+  ```python
+  x = tf.Variable([1,2,3], dtype=tf.float32)
+  grad = tf.constant([0.1, 0.2, 0.3])
+  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
+  optimizer.apply_gradients(zip([grad], [x]))
+  ```
+
+  @end_compatibility
+  """
+
+  def __init__(self,
+               learning_rate=0.001,
+               beta1=0.9,
+               beta2=0.999,
+               epsilon=1e-8,
+               use_locking=False,
+               name="Adam"):
+    r"""Construct a new Adam optimizer.
+
+    Initialization:
+
+    $$m_0 := 0 \text{(Initialize initial 1st moment vector)}$$
+    $$v_0 := 0 \text{(Initialize initial 2nd moment vector)}$$
+    $$t := 0 \text{(Initialize timestep)}$$
+
+    The update rule for `variable` with gradient `g` uses an optimization
+    described at the end of section 2 of the paper:
+
+    $$t := t + 1$$
+    $$\text{lr}_t := \mathrm{learning_rate} *
+      \sqrt{1 - \beta_2^t} / (1 - \beta_1^t)$$
+
+    $$m_t := \beta_1 * m_{t-1} + (1 - \beta_1) * g$$
+    $$v_t := \beta_2 * v_{t-1} + (1 - \beta_2) * g * g$$
+    $$\text{variable} := \text{variable} -
+      \text{lr}_t * m_t / (\sqrt{v_t} + \epsilon)$$
+
+    The default value of 1e-8 for epsilon might not be a good default in
+    general. For example, when training an Inception network on ImageNet a
+    current good choice is 1.0 or 0.1. Note that since AdamOptimizer uses the
+    formulation just before Section 2.1 of the Kingma and Ba paper rather than
+    the formulation in Algorithm 1, the "epsilon" referred to here is "epsilon
+    hat" in the paper.
+
+    The sparse implementation of this algorithm (used when the gradient is an
+    IndexedSlices object, typically because of `tf.gather` or an embedding
+    lookup in the forward pass) does apply momentum to variable slices even if
+    they were not used in the forward pass (meaning they have a gradient equal
+    to zero). Momentum decay (beta1) is also applied to the entire momentum
+    accumulator. This means that the sparse behavior is equivalent to the dense
+    behavior (in contrast to some momentum implementations which ignore momentum
+    unless a variable slice was actually used).
+
+    Args:
+      learning_rate: A Tensor or a floating point value.  The learning rate.
+      beta1: A float value or a constant float tensor. The exponential decay
+        rate for the 1st moment estimates.
+      beta2: A float value or a constant float tensor. The exponential decay
+        rate for the 2nd moment estimates.
+      epsilon: A small constant for numerical stability. This epsilon is
+        "epsilon hat" in the Kingma and Ba paper (in the formula just before
+        Section 2.1), not the epsilon in Algorithm 1 of the paper.
+      use_locking: If True use locks for update operations.
+      name: Optional name for the operations created when applying gradients.
+        Defaults to "Adam".
+
+
+    """
+
+    super(AdamOptimizer, self).__init__(use_locking, name)
+    self._lr = learning_rate
+    self._beta1 = beta1
+    self._beta2 = beta2
+    self._epsilon = epsilon
+
+    # Tensor versions of the constructor arguments, created in _prepare().
+    self._lr_t = None
+    self._beta1_t = None
+    self._beta2_t = None
+    self._epsilon_t = None
+
+  def _get_beta_accumulators(self):
+    with ops.init_scope():
+      if context.executing_eagerly():
+        graph = None
+      else:
+        graph = ops.get_default_graph()
+      return (self._get_non_slot_variable("beta1_power", graph=graph),
+              self._get_non_slot_variable("beta2_power", graph=graph))
+
+  def _create_slots(self, var_list):
+    # Create the beta1 and beta2 accumulators on the same device as the first
+    # variable. Sort the var_list to make sure this device is consistent across
+    # workers (these need to go on the same PS, otherwise some updates are
+    # silently ignored).
+    first_var = min(var_list, key=lambda x: x.name)
+    self._create_non_slot_variable(
+        initial_value=self._beta1, name="beta1_power", colocate_with=first_var)
+    self._create_non_slot_variable(
+        initial_value=self._beta2, name="beta2_power", colocate_with=first_var)
+
+    # Create slots for the first and second moments.
+    for v in var_list:
+      self._zeros_slot(v, "m", self._name)
+      self._zeros_slot(v, "v", self._name)
+
+  def _prepare(self):
+    lr = self._call_if_callable(self._lr)
+    beta1 = self._call_if_callable(self._beta1)
+    beta2 = self._call_if_callable(self._beta2)
+    epsilon = self._call_if_callable(self._epsilon)
+
+    self._lr_t = ops.convert_to_tensor(lr, name="learning_rate")
+    self._beta1_t = ops.convert_to_tensor(beta1, name="beta1")
+    self._beta2_t = ops.convert_to_tensor(beta2, name="beta2")
+    self._epsilon_t = ops.convert_to_tensor(epsilon, name="epsilon")
+
+  def _apply_dense(self, grad, var):
+    m = self.get_slot(var, "m")
+    v = self.get_slot(var, "v")
+    beta1_power, beta2_power = self._get_beta_accumulators()
+    return training_ops.apply_adam(
+        var,
+        m,
+        v,
+        math_ops.cast(beta1_power, var.dtype.base_dtype),
+        math_ops.cast(beta2_power, var.dtype.base_dtype),
+        math_ops.cast(self._lr_t, var.dtype.base_dtype),
+        math_ops.cast(self._beta1_t, var.dtype.base_dtype),
+        math_ops.cast(self._beta2_t, var.dtype.base_dtype),
+        math_ops.cast(self._epsilon_t, var.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking).op
+
+  def _resource_apply_dense(self, grad, var):
+    m = self.get_slot(var, "m")
+    v = self.get_slot(var, "v")
+    beta1_power, beta2_power = self._get_beta_accumulators()
+    return training_ops.resource_apply_adam(
+        var.handle,
+        m.handle,
+        v.handle,
+        math_ops.cast(beta1_power, grad.dtype.base_dtype),
+        math_ops.cast(beta2_power, grad.dtype.base_dtype),
+        math_ops.cast(self._lr_t, grad.dtype.base_dtype),
+        math_ops.cast(self._beta1_t, grad.dtype.base_dtype),
+        math_ops.cast(self._beta2_t, grad.dtype.base_dtype),
+        math_ops.cast(self._epsilon_t, grad.dtype.base_dtype),
+        grad,
+        use_locking=self._use_locking)
+
+  def _apply_sparse_shared(self, grad, var, indices, scatter_add):
+    beta1_power, beta2_power = self._get_beta_accumulators()
+    beta1_power = math_ops.cast(beta1_power, var.dtype.base_dtype)
+    beta2_power = math_ops.cast(beta2_power, var.dtype.base_dtype)
+    lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)
+    beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)
+    beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)
+    epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)
+    lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))
+    # m_t = beta1 * m + (1 - beta1) * g_t
+    m = self.get_slot(var, "m")
+    m_scaled_g_values = grad * (1 - beta1_t)
+    m_t = state_ops.assign(m, m * beta1_t, use_locking=self._use_locking)
+    with ops.control_dependencies([m_t]):
+      m_t = scatter_add(m, indices, m_scaled_g_values)
+    # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)
+    v = self.get_slot(var, "v")
+    v_scaled_g_values = (grad * grad) * (1 - beta2_t)
+    v_t = state_ops.assign(v, v * beta2_t, use_locking=self._use_locking)
+    with ops.control_dependencies([v_t]):
+      v_t = scatter_add(v, indices, v_scaled_g_values)
+    v_sqrt = math_ops.sqrt(v_t)
+    var_update = state_ops.assign_sub(
+        var, lr * m_t / (v_sqrt + epsilon_t), use_locking=self._use_locking)
+    return control_flow_ops.group(*[var_update, m_t, v_t])
+
+  def _apply_sparse(self, grad, var):
+    return self._apply_sparse_shared(
+        grad.values,
+        var,
+        grad.indices,
+        lambda x, i, v: state_ops.scatter_add(  # pylint: disable=g-long-lambda
+            x,
+            i,
+            v,
+            use_locking=self._use_locking))
+
+  def _resource_scatter_add(self, x, i, v):
+    with ops.control_dependencies(
+        [resource_variable_ops.resource_scatter_add(x.handle, i, v)]):
+      return x.value()
+
+  def _resource_apply_sparse(self, grad, var, indices):
+    return self._apply_sparse_shared(grad, var, indices,
+                                     self._resource_scatter_add)
+
+  def _finish(self, update_ops, name_scope):
+    # Update the power accumulators.
+    with ops.control_dependencies(update_ops):
+      beta1_power, beta2_power = self._get_beta_accumulators()
+      with ops.colocate_with(beta1_power):
+        update_beta1 = beta1_power.assign(
+            beta1_power * self._beta1_t, use_locking=self._use_locking)
+        update_beta2 = beta2_power.assign(
+            beta2_power * self._beta2_t, use_locking=self._use_locking)
+    return control_flow_ops.group(
+        *update_ops + [update_beta1, update_beta2], name=name_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/basic_loops.py

@@ -0,0 +1,61 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Basic loop for training."""
+from tensorflow.python.framework import errors
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["train.basic_train_loop"])
+def basic_train_loop(supervisor,
+                     train_step_fn,
+                     args=None,
+                     kwargs=None,
+                     master=""):
+  """Basic loop to train a model.
+
+  Calls `train_step_fn` in a loop to train a model.  The function is called as:
+
+  ```python
+  train_step_fn(session, *args, **kwargs)
+  ```
+
+  It is passed a `tf.compat.v1.Session` in addition to `args` and `kwargs`.  The
+  function
+  typically runs one training step in the session.
+
+  Args:
+    supervisor: `tf.compat.v1.train.Supervisor` to run the training services.
+    train_step_fn: Callable to execute one training step.  Called repeatedly as
+      `train_step_fn(session, *args **kwargs)`.
+    args: Optional positional arguments passed to `train_step_fn`.
+    kwargs: Optional keyword arguments passed to `train_step_fn`.
+    master: Master to use to create the training session.  Defaults to `""`
+      which causes the session to be created in the local process.
+  """
+  if args is None:
+    args = []
+  if kwargs is None:
+    kwargs = {}
+  should_retry = True
+  while should_retry:
+    try:
+      should_retry = False
+      with supervisor.managed_session(master) as sess:
+        while not supervisor.should_stop():
+          train_step_fn(sess, *args, **kwargs)
+    except errors.AbortedError:
+      # Always re-run on AbortedError as it indicates a restart of one of the
+      # distributed tensorflow servers.
+      should_retry = True

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/basic_session_run_hooks.py

@@ -0,0 +1,1118 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Some common SessionRunHook classes.
+
+Note that the symbols that are exported to v1 tf.train namespace are also
+exported to v2 in tf.estimator namespace. See
+https://github.com/tensorflow/estimator/blob/master/tensorflow_estimator/python/estimator/hooks/basic_session_run_hooks.py
+"""
+
+import os
+import time
+
+import numpy as np
+
+from tensorflow.core.framework.summary_pb2 import Summary
+from tensorflow.core.protobuf import config_pb2
+from tensorflow.core.util.event_pb2 import SessionLog
+from tensorflow.python.client import timeline
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import errors
+from tensorflow.python.framework import meta_graph
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import init_ops
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.platform import gfile
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.training import session_run_hook
+from tensorflow.python.training import training_util
+from tensorflow.python.training.session_run_hook import SessionRunArgs
+from tensorflow.python.training.summary_io import SummaryWriterCache
+from tensorflow.python.util.tf_export import tf_export
+
+_HOOKS = "hooks"
+_STEPS_PER_RUN_VAR = "steps_per_run"
+
+
+class _HookTimer:
+  """Base timer for determining when Hooks should trigger.
+
+  Should not be instantiated directly.
+  """
+
+  def __init__(self):
+    pass
+
+  def reset(self):
+    """Resets the timer."""
+    pass
+
+  def should_trigger_for_step(self, step):
+    """Return true if the timer should trigger for the specified step."""
+    raise NotImplementedError
+
+  def update_last_triggered_step(self, step):
+    """Update the last triggered time and step number.
+
+    Args:
+      step: The current step.
+
+    Returns:
+      A pair `(elapsed_time, elapsed_steps)`, where `elapsed_time` is the number
+      of seconds between the current trigger and the last one (a float), and
+      `elapsed_steps` is the number of steps between the current trigger and
+      the last one. Both values will be set to `None` on the first trigger.
+    """
+    raise NotImplementedError
+
+  def last_triggered_step(self):
+    """Returns the last triggered time step or None if never triggered."""
+    raise NotImplementedError
+
+
+@tf_export(v1=["train.SecondOrStepTimer"])
+class SecondOrStepTimer(_HookTimer):
+  """Timer that triggers at most once every N seconds or once every N steps.
+
+  This symbol is also exported to v2 in tf.estimator namespace. See
+  https://github.com/tensorflow/estimator/blob/master/tensorflow_estimator/python/estimator/hooks/basic_session_run_hooks.py
+  """
+
+  def __init__(self, every_secs=None, every_steps=None):
+    self.reset()
+    self._every_secs = every_secs
+    self._every_steps = every_steps
+
+    if self._every_secs is None and self._every_steps is None:
+      raise ValueError("Either every_secs or every_steps should be provided.")
+    if (self._every_secs is not None) and (self._every_steps is not None):
+      raise ValueError("Can not provide both every_secs and every_steps.")
+
+    super(SecondOrStepTimer, self).__init__()
+
+  def reset(self):
+    self._last_triggered_step = None
+    self._last_triggered_time = None
+
+  def should_trigger_for_step(self, step):
+    """Return true if the timer should trigger for the specified step.
+
+    Args:
+      step: Training step to trigger on.
+
+    Returns:
+      True if the difference between the current time and the time of the last
+      trigger exceeds `every_secs`, or if the difference between the current
+      step and the last triggered step exceeds `every_steps`. False otherwise.
+    """
+    if self._last_triggered_step is None:
+      return True
+
+    if self._last_triggered_step == step:
+      return False
+
+    if self._every_secs is not None:
+      if time.time() >= self._last_triggered_time + self._every_secs:
+        return True
+
+    if self._every_steps is not None:
+      if step >= self._last_triggered_step + self._every_steps:
+        return True
+
+    return False
+
+  def update_last_triggered_step(self, step):
+    current_time = time.time()
+    if self._last_triggered_time is None:
+      elapsed_secs = None
+      elapsed_steps = None
+    else:
+      elapsed_secs = current_time - self._last_triggered_time
+      elapsed_steps = step - self._last_triggered_step
+
+    self._last_triggered_time = current_time
+    self._last_triggered_step = step
+    return (elapsed_secs, elapsed_steps)
+
+  def last_triggered_step(self):
+    return self._last_triggered_step
+
+
+class NeverTriggerTimer(_HookTimer):
+  """Timer that never triggers."""
+
+  def should_trigger_for_step(self, step):
+    _ = step
+    return False
+
+  def update_last_triggered_step(self, step):
+    _ = step
+    return (None, None)
+
+  def last_triggered_step(self):
+    return None
+
+
+@tf_export(v1=["train.LoggingTensorHook"])
+class LoggingTensorHook(session_run_hook.SessionRunHook):
+  """Prints the given tensors every N local steps, every N seconds, or at end.
+
+  The tensors will be printed to the log, with `INFO` severity. If you are not
+  seeing the logs, you might want to add the following line after your imports:
+
+  ```python
+    tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.INFO)
+  ```
+
+  Note that if `at_end` is True, `tensors` should not include any tensor
+  whose evaluation produces a side effect such as consuming additional inputs.
+
+  @compatibility(TF2)
+  Please check this [notebook][notebook] on how to migrate the API to TF2.
+
+  [notebook]:https://github.com/tensorflow/docs/blob/master/site/en/guide/migrate/logging_stop_hook.ipynb
+
+  @end_compatibility
+
+  """
+
+  def __init__(self,
+               tensors,
+               every_n_iter=None,
+               every_n_secs=None,
+               at_end=False,
+               formatter=None):
+    """Initializes a `LoggingTensorHook`.
+
+    Args:
+      tensors: `dict` that maps string-valued tags to tensors/tensor names, or
+        `iterable` of tensors/tensor names.
+      every_n_iter: `int`, print the values of `tensors` once every N local
+        steps taken on the current worker.
+      every_n_secs: `int` or `float`, print the values of `tensors` once every N
+        seconds. Exactly one of `every_n_iter` and `every_n_secs` should be
+        provided.
+      at_end: `bool` specifying whether to print the values of `tensors` at the
+        end of the run.
+      formatter: function, takes dict of `tag`->`Tensor` and returns a string.
+        If `None` uses default printing all tensors.
+
+    Raises:
+      ValueError: if `every_n_iter` is non-positive.
+    """
+    only_log_at_end = (
+        at_end and (every_n_iter is None) and (every_n_secs is None))
+    if (not only_log_at_end and
+        (every_n_iter is None) == (every_n_secs is None)):
+      raise ValueError(
+          "either at_end and/or exactly one of every_n_iter and every_n_secs "
+          "must be provided.")
+    if every_n_iter is not None and every_n_iter <= 0:
+      raise ValueError("invalid every_n_iter=%s." % every_n_iter)
+    if not isinstance(tensors, dict):
+      self._tag_order = tensors
+      tensors = {item: item for item in tensors}
+    else:
+      self._tag_order = sorted(tensors.keys())
+    self._tensors = tensors
+    self._formatter = formatter
+    self._timer = (
+        NeverTriggerTimer() if only_log_at_end else SecondOrStepTimer(
+            every_secs=every_n_secs, every_steps=every_n_iter))
+    self._log_at_end = at_end
+
+  def begin(self):
+    self._timer.reset()
+    self._iter_count = 0
+    # Convert names to tensors if given
+    self._current_tensors = {
+        tag: _as_graph_element(tensor)
+        for (tag, tensor) in self._tensors.items()
+    }
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    self._should_trigger = self._timer.should_trigger_for_step(self._iter_count)
+    if self._should_trigger:
+      return SessionRunArgs(self._current_tensors)
+    else:
+      return None
+
+  def _log_tensors(self, tensor_values):
+    original = np.get_printoptions()
+    np.set_printoptions(suppress=True)
+    elapsed_secs, _ = self._timer.update_last_triggered_step(self._iter_count)
+    if self._formatter:
+      logging.info(self._formatter(tensor_values))
+    else:
+      stats = []
+      for tag in self._tag_order:
+        stats.append("%s = %s" % (tag, tensor_values[tag]))
+      if elapsed_secs is not None:
+        logging.info("%s (%.3f sec)", ", ".join(stats), elapsed_secs)
+      else:
+        logging.info("%s", ", ".join(stats))
+    np.set_printoptions(**original)
+
+  def after_run(self, run_context, run_values):
+    _ = run_context
+    if self._should_trigger:
+      self._log_tensors(run_values.results)
+
+    self._iter_count += 1
+
+  def end(self, session):
+    if self._log_at_end:
+      values = session.run(self._current_tensors)
+      self._log_tensors(values)
+
+
+def get_or_create_steps_per_run_variable():
+  """Gets or creates the steps_per_run variable.
+
+  In Estimator, the user provided computation, the model_fn, is wrapped
+  inside a tf.while_loop for peak performance. The iterations of the loop are
+  specified by this variable, which adjusts its value on the CPU after each
+  device program execution and before the next execution.
+
+  The purpose of using a variable, rather than a constant, is to allow
+  Estimator adapt the device training iterations according to the final steps
+  specified by users. For example, if the user sets the steps_per_run as
+  4 and steps as 10 in Estimator.train(), the steps_per_run
+  variable will have the following value before each training run.
+
+      - 1-st execution: steps_per_run = 4
+      - 2-nd execution: steps_per_run = 4
+      - 3-rd execution: steps_per_run = 2
+
+  As model_fn increases the global step once per train_op invocation, the global
+  step is 10 after all executions, matching the steps=10 inputs passed in by
+  users.
+
+  Returns:
+    A TF non-trainable resource variable.
+
+  Raises:
+    RuntimeError: If multi steps_per_run variables were found.
+  """
+  graph = ops.get_default_graph()
+  collection_name = "{}_{}".format(_HOOKS, _STEPS_PER_RUN_VAR)
+  steps_per_run_vars = graph.get_collection(collection_name)
+  if len(steps_per_run_vars) == 1:
+    return steps_per_run_vars[0]
+  elif len(steps_per_run_vars) > 1:
+    raise RuntimeError("Multiple steps_per_run_var in collection.")
+
+  with variable_scope.variable_scope(_HOOKS, reuse=variable_scope.AUTO_REUSE):
+    return variable_scope.get_variable(
+        _STEPS_PER_RUN_VAR,
+        initializer=init_ops.ones_initializer(),
+        shape=[],
+        dtype=dtypes.int32,
+        trainable=False,
+        collections=[collection_name, ops.GraphKeys.LOCAL_VARIABLES],
+        use_resource=True)
+
+
+class _MultiStepStopAtStepHook(session_run_hook.SessionRunHook):
+  """Hook that requests stop at a specified step."""
+
+  def __init__(self, num_steps=None, last_step=None, steps_per_run=1):
+    """Initializes a `MultiStepStopAtStepHook`.
+
+    This hook requests stop after either a number of steps have been
+    executed or a last step has been reached. Only one of the two options can be
+    specified.
+
+    if `num_steps` is specified, it indicates the number of steps to execute
+    after `begin()` is called. If instead `last_step` is specified, it
+    indicates the last step we want to execute, as passed to the `after_run()`
+    call.
+
+    In Estimator, the user provided computation, the model_fn, is wrapped
+    inside a tf.while_loop for peak performance. The steps_per_run variable
+    determines the number of iterations of the loop before returning to the CPU.
+
+    Args:
+      num_steps: Number of steps to execute.
+      last_step: Step after which to stop.
+      steps_per_run: Number of steps executed per run call.
+
+    Raises:
+      ValueError: If one of the arguments is invalid.
+    """
+    if num_steps is None and last_step is None:
+      raise ValueError("One of num_steps or last_step must be specified.")
+    if num_steps is not None and last_step is not None:
+      raise ValueError("Only one of num_steps or last_step can be specified.")
+    if steps_per_run is None or steps_per_run < 1:
+      raise ValueError("steps_per_run should be greater than 0")
+    self._num_steps = num_steps
+    self._last_step = last_step
+    self._steps_per_run_initial_value = steps_per_run
+
+  def begin(self):
+    self._global_step_tensor = training_util.get_global_step()
+    if self._global_step_tensor is None:
+      raise RuntimeError("Global step should be created to use StopAtStepHook.")
+    self._steps_per_run_variable = get_or_create_steps_per_run_variable()
+
+  def _update_steps_per_run_variable(self, global_step, session):
+    steps = min(self._last_step - global_step,
+                self._steps_per_run_initial_value)
+    self._steps_per_run_variable.load(steps, session=session)
+
+  def after_create_session(self, session, coord):
+    global_step = session.run(self._global_step_tensor)
+    if self._last_step is None:
+      self._last_step = global_step + self._num_steps
+    self._update_steps_per_run_variable(global_step, session)
+
+  def after_run(self, run_context, run_values):
+    # Global step cannot be retrieved via SessionRunArgs and before_run due to
+    # race condition in hook execution.
+    global_step = run_context.session.run(self._global_step_tensor)
+    if global_step >= self._last_step:
+      run_context.request_stop()
+    else:
+      self._update_steps_per_run_variable(global_step, run_context.session)
+
+
+@tf_export(v1=["train.StopAtStepHook"])
+class StopAtStepHook(session_run_hook.SessionRunHook):
+  """Hook that requests stop at a specified step.
+
+  @compatibility(TF2)
+  Please check this [notebook][notebook] on how to migrate the API to TF2.
+
+  [notebook]:https://github.com/tensorflow/docs/blob/master/site/en/guide/migrate/logging_stop_hook.ipynb
+
+  @end_compatibility
+  """
+
+  def __init__(self, num_steps=None, last_step=None):
+    """Initializes a `StopAtStepHook`.
+
+    This hook requests stop after either a number of steps have been
+    executed or a last step has been reached. Only one of the two options can be
+    specified.
+
+    if `num_steps` is specified, it indicates the number of steps to execute
+    after `begin()` is called. If instead `last_step` is specified, it
+    indicates the last step we want to execute, as passed to the `after_run()`
+    call.
+
+    Args:
+      num_steps: Number of steps to execute.
+      last_step: Step after which to stop.
+
+    Raises:
+      ValueError: If one of the arguments is invalid.
+    """
+    if num_steps is None and last_step is None:
+      raise ValueError("One of num_steps or last_step must be specified.")
+    if num_steps is not None and last_step is not None:
+      raise ValueError("Only one of num_steps or last_step can be specified.")
+    self._num_steps = num_steps
+    self._last_step = last_step
+
+  def begin(self):
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError("Global step should be created to use StopAtStepHook.")
+
+  def after_create_session(self, session, coord):
+    if self._last_step is None:
+      global_step = session.run(self._global_step_tensor)
+      self._last_step = global_step + self._num_steps
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    return SessionRunArgs(self._global_step_tensor)
+
+  def after_run(self, run_context, run_values):
+    global_step = run_values.results + 1
+    if global_step >= self._last_step:
+      # Check latest global step to ensure that the targeted last step is
+      # reached. global_step read tensor is the value of global step
+      # before running the operation. We're not sure whether current session.run
+      # incremented the global_step or not. Here we're checking it.
+
+      step = run_context.session.run(self._global_step_tensor)
+      if step >= self._last_step:
+        run_context.request_stop()
+
+
+@tf_export(v1=["train.CheckpointSaverListener"])
+class CheckpointSaverListener:
+  """Interface for listeners that take action before or after checkpoint save.
+
+  `CheckpointSaverListener` triggers only in steps when `CheckpointSaverHook` is
+  triggered, and provides callbacks at the following points:
+   - before using the session
+   - before each call to `Saver.save()`
+   - after each call to `Saver.save()`
+   - at the end of session
+
+  To use a listener, implement a class and pass the listener to a
+  `CheckpointSaverHook`, as in this example:
+
+  ```python
+  class ExampleCheckpointSaverListener(CheckpointSaverListener):
+    def begin(self):
+      # You can add ops to the graph here.
+      print('Starting the session.')
+      self.your_tensor = ...
+
+    def before_save(self, session, global_step_value):
+      print('About to write a checkpoint')
+
+    def after_save(self, session, global_step_value):
+      print('Done writing checkpoint.')
+      if decided_to_stop_training():
+        return True
+
+    def end(self, session, global_step_value):
+      print('Done with the session.')
+
+  ...
+  listener = ExampleCheckpointSaverListener()
+  saver_hook = tf.estimator.CheckpointSaverHook(
+      checkpoint_dir, listeners=[listener])
+  with
+  tf.compat.v1.train.MonitoredTrainingSession(chief_only_hooks=[saver_hook]):
+    ...
+  ```
+
+  A `CheckpointSaverListener` may simply take some action after every
+  checkpoint save. It is also possible for the listener to use its own schedule
+  to act less frequently, e.g. based on global_step_value. In this case,
+  implementors should implement the `end()` method to handle actions related to
+  the last checkpoint save. But the listener should not act twice if
+  `after_save()` already handled this last checkpoint save.
+
+  A `CheckpointSaverListener` can request training to be stopped, by returning
+  True in `after_save`. Please note that, in replicated distributed training
+  setting, only `chief` should use this behavior. Otherwise each worker will do
+  their own evaluation, which may be wasteful of resources.
+  """
+
+  def begin(self):
+    pass
+
+  def before_save(self, session, global_step_value):
+    pass
+
+  def after_save(self, session, global_step_value):
+    pass
+
+  def end(self, session, global_step_value):
+    pass
+
+
+@tf_export(v1=["train.CheckpointSaverHook"])
+class CheckpointSaverHook(session_run_hook.SessionRunHook):
+  """Saves checkpoints every N steps or seconds."""
+
+  def __init__(self,
+               checkpoint_dir,
+               save_secs=None,
+               save_steps=None,
+               saver=None,
+               checkpoint_basename="model.ckpt",
+               scaffold=None,
+               listeners=None,
+               save_graph_def=True):
+    """Initializes a `CheckpointSaverHook`.
+
+    Args:
+      checkpoint_dir: `str`, base directory for the checkpoint files.
+      save_secs: `int`, save every N secs.
+      save_steps: `int`, save every N steps.
+      saver: `Saver` object, used for saving.
+      checkpoint_basename: `str`, base name for the checkpoint files.
+      scaffold: `Scaffold`, use to get saver object.
+      listeners: List of `CheckpointSaverListener` subclass instances. Used for
+        callbacks that run immediately before or after this hook saves the
+        checkpoint.
+      save_graph_def: Whether to save the GraphDef and MetaGraphDef to
+        `checkpoint_dir`. The GraphDef is saved after the session is created as
+        `graph.pbtxt`. MetaGraphDefs are saved out for every checkpoint as
+        `model.ckpt-*.meta`.
+
+    Raises:
+      ValueError: One of `save_steps` or `save_secs` should be set.
+      ValueError: At most one of `saver` or `scaffold` should be set.
+    """
+    logging.info("Create CheckpointSaverHook.")
+    if saver is not None and scaffold is not None:
+      raise ValueError("You cannot provide both saver and scaffold.")
+    self._saver = saver
+    self._checkpoint_dir = checkpoint_dir
+    self._save_path = os.path.join(checkpoint_dir, checkpoint_basename)
+    self._scaffold = scaffold
+    self._timer = SecondOrStepTimer(
+        every_secs=save_secs, every_steps=save_steps)
+    self._listeners = listeners or []
+    # Set sufficiently high default that it never skips checking the actual
+    # global step counter -- unless the user overrides it with the right value
+    # for the steps_per_run.
+    self._steps_per_run = 1000000
+    self._save_graph_def = save_graph_def
+
+  def _set_steps_per_run(self, steps_per_run):
+    self._steps_per_run = steps_per_run
+
+  def begin(self):
+    self._summary_writer = SummaryWriterCache.get(self._checkpoint_dir)
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError(
+          "Global step should be created to use CheckpointSaverHook.")
+    for l in self._listeners:
+      l.begin()
+
+  def after_create_session(self, session, coord):
+    global_step = session.run(self._global_step_tensor)
+    if self._save_graph_def:
+      # We do write graph and saver_def at the first call of before_run.
+      # We cannot do this in begin, since we let other hooks to change graph and
+      # add variables in begin. Graph is finalized after all begin calls.
+      training_util.write_graph(
+          ops.get_default_graph().as_graph_def(add_shapes=True),
+          self._checkpoint_dir, "graph.pbtxt")
+    saver_def = self._get_saver().saver_def if self._get_saver() else None
+    graph = ops.get_default_graph()
+    meta_graph_def = meta_graph.create_meta_graph_def(
+        graph_def=graph.as_graph_def(add_shapes=True), saver_def=saver_def)
+    self._summary_writer.add_graph(graph)
+    self._summary_writer.add_meta_graph(meta_graph_def)
+    # The checkpoint saved here is the state at step "global_step".
+    self._save(session, global_step)
+    self._timer.update_last_triggered_step(global_step)
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    return SessionRunArgs(self._global_step_tensor)
+
+  def after_run(self, run_context, run_values):
+    stale_global_step = run_values.results
+    if self._timer.should_trigger_for_step(stale_global_step +
+                                           self._steps_per_run):
+      # get the real value after train op.
+      global_step = run_context.session.run(self._global_step_tensor)
+      if self._timer.should_trigger_for_step(global_step):
+        self._timer.update_last_triggered_step(global_step)
+        if self._save(run_context.session, global_step):
+          run_context.request_stop()
+
+  def end(self, session):
+    last_step = session.run(self._global_step_tensor)
+    if last_step != self._timer.last_triggered_step():
+      self._save(session, last_step)
+    for l in self._listeners:
+      l.end(session, last_step)
+
+  def _save(self, session, step):
+    """Saves the latest checkpoint, returns should_stop."""
+    logging.info("Calling checkpoint listeners before saving checkpoint %d...",
+                 step)
+    for l in self._listeners:
+      l.before_save(session, step)
+
+    logging.info("Saving checkpoints for %d into %s.", step, self._save_path)
+    self._get_saver().save(session, self._save_path, global_step=step,
+                           write_meta_graph=self._save_graph_def)
+    self._summary_writer.add_session_log(
+        SessionLog(
+            status=SessionLog.CHECKPOINT, checkpoint_path=self._save_path),
+        step)
+    logging.info("Calling checkpoint listeners after saving checkpoint %d...",
+                 step)
+    should_stop = False
+    for l in self._listeners:
+      if l.after_save(session, step):
+        logging.info(
+            "A CheckpointSaverListener requested that training be stopped. "
+            "listener: {}".format(l))
+        should_stop = True
+    return should_stop
+
+  def _get_saver(self):
+    if self._saver is not None:
+      return self._saver
+    elif self._scaffold is not None:
+      return self._scaffold.saver
+
+    # Get saver from the SAVERS collection if present.
+    collection_key = ops.GraphKeys.SAVERS
+    savers = ops.get_collection(collection_key)
+    if not savers:
+      raise RuntimeError(
+          "No items in collection {}. Please add a saver to the collection "
+          "or provide a saver or scaffold.".format(collection_key))
+    elif len(savers) > 1:
+      raise RuntimeError(
+          "More than one item in collection {}. "
+          "Please indicate which one to use by passing it to the constructor."
+          .format(collection_key))
+
+    self._saver = savers[0]
+    return savers[0]
+
+
+@tf_export(v1=["train.StepCounterHook"])
+class StepCounterHook(session_run_hook.SessionRunHook):
+  """Hook that counts steps per second."""
+
+  def __init__(self,
+               every_n_steps=100,
+               every_n_secs=None,
+               output_dir=None,
+               summary_writer=None):
+
+    if (every_n_steps is None) == (every_n_secs is None):
+      raise ValueError(
+          "exactly one of every_n_steps and every_n_secs should be provided.")
+    self._timer = SecondOrStepTimer(
+        every_steps=every_n_steps, every_secs=every_n_secs)
+
+    self._summary_writer = summary_writer
+    self._output_dir = output_dir
+    self._last_global_step = None
+    self._steps_per_run = 1
+
+  def _set_steps_per_run(self, steps_per_run):
+    self._steps_per_run = steps_per_run
+
+  def begin(self):
+    if self._summary_writer is None and self._output_dir:
+      self._summary_writer = SummaryWriterCache.get(self._output_dir)
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError(
+          "Global step should be created to use StepCounterHook.")
+    self._summary_tag = training_util.get_global_step().op.name + "/sec"
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    return SessionRunArgs(self._global_step_tensor)
+
+  def _log_and_record(self, elapsed_steps, elapsed_time, global_step):
+    steps_per_sec = elapsed_steps / elapsed_time
+    if self._summary_writer is not None:
+      summary = Summary(value=[
+          Summary.Value(tag=self._summary_tag, simple_value=steps_per_sec)
+      ])
+      self._summary_writer.add_summary(summary, global_step)
+    logging.info("%s: %g", self._summary_tag, steps_per_sec)
+
+  def after_run(self, run_context, run_values):
+    _ = run_context
+
+    stale_global_step = run_values.results
+    if self._timer.should_trigger_for_step(stale_global_step +
+                                           self._steps_per_run):
+      # get the real value after train op.
+      global_step = run_context.session.run(self._global_step_tensor)
+      if self._timer.should_trigger_for_step(global_step):
+        elapsed_time, elapsed_steps = self._timer.update_last_triggered_step(
+            global_step)
+        if elapsed_time is not None:
+          self._log_and_record(elapsed_steps, elapsed_time, global_step)
+
+    # Check whether the global step has been increased. Here, we do not use the
+    # timer.last_triggered_step as the timer might record a different global
+    # step value such that the comparison could be unreliable. For simplicity,
+    # we just compare the stale_global_step with previously recorded version.
+    if stale_global_step == self._last_global_step:
+      # Here, we give a warning in the first 5 times if we have observed that
+      # the global step has not been increased. For some Optimizers, the global
+      # step is not increased each time by design. For example,
+      # SyncReplicaOptimizer doesn't increase the global step in worker's main
+      # train step.
+      logging.log_first_n(
+          logging.WARN,
+          "It seems that global step (tf.train.get_global_step) has not "
+          "been increased. Current value (could be stable): %s vs previous "
+          "value: %s. You could increase the global step by passing "
+          "tf.train.get_global_step() to Optimizer.apply_gradients or "
+          "Optimizer.minimize.", 5, stale_global_step, self._last_global_step)
+
+    self._last_global_step = stale_global_step
+
+
+@tf_export(v1=["train.NanLossDuringTrainingError"])
+class NanLossDuringTrainingError(RuntimeError):
+
+  def __str__(self):
+    return "NaN loss during training."
+
+
+@tf_export(v1=["train.NanTensorHook"])
+class NanTensorHook(session_run_hook.SessionRunHook):
+  """Monitors the loss tensor and stops training if loss is NaN.
+
+  Can either fail with exception or just stop training.
+  """
+
+  def __init__(self, loss_tensor, fail_on_nan_loss=True):
+    """Initializes a `NanTensorHook`.
+
+    Args:
+      loss_tensor: `Tensor`, the loss tensor.
+      fail_on_nan_loss: `bool`, whether to raise exception when loss is NaN.
+    """
+    self._loss_tensor = loss_tensor
+    self._fail_on_nan_loss = fail_on_nan_loss
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    return SessionRunArgs(self._loss_tensor)
+
+  def after_run(self, run_context, run_values):
+    if np.isnan(run_values.results):
+      failure_message = "Model diverged with loss = NaN."
+      if self._fail_on_nan_loss:
+        logging.error(failure_message)
+        raise NanLossDuringTrainingError
+      else:
+        logging.warning(failure_message)
+        # We don't raise an error but we request stop without an exception.
+        run_context.request_stop()
+
+
+@tf_export(v1=["train.SummarySaverHook"])
+class SummarySaverHook(session_run_hook.SessionRunHook):
+  """Saves summaries every N steps."""
+
+  def __init__(self,
+               save_steps=None,
+               save_secs=None,
+               output_dir=None,
+               summary_writer=None,
+               scaffold=None,
+               summary_op=None):
+    """Initializes a `SummarySaverHook`.
+
+    Args:
+      save_steps: `int`, save summaries every N steps. Exactly one of
+        `save_secs` and `save_steps` should be set.
+      save_secs: `int`, save summaries every N seconds.
+      output_dir: `string`, the directory to save the summaries to. Only used if
+        no `summary_writer` is supplied.
+      summary_writer: `SummaryWriter`. If `None` and an `output_dir` was passed,
+        one will be created accordingly.
+      scaffold: `Scaffold` to get summary_op if it's not provided.
+      summary_op: `Tensor` of type `string` containing the serialized `Summary`
+        protocol buffer or a list of `Tensor`. They are most likely an output by
+        TF summary methods like `tf.compat.v1.summary.scalar` or
+        `tf.compat.v1.summary.merge_all`. It can be passed in as one tensor; if
+        more than one, they must be passed in as a list.
+
+    Raises:
+      ValueError: Exactly one of scaffold or summary_op should be set.
+    """
+    if ((scaffold is None and summary_op is None) or
+        (scaffold is not None and summary_op is not None)):
+      raise ValueError(
+          "Exactly one of scaffold or summary_op must be provided.")
+    self._summary_op = summary_op
+    self._summary_writer = summary_writer
+    self._output_dir = output_dir
+    self._scaffold = scaffold
+    self._timer = SecondOrStepTimer(
+        every_secs=save_secs, every_steps=save_steps)
+    # TODO(mdan): Throw an error if output_dir and summary_writer are None.
+
+  def begin(self):
+    if self._summary_writer is None and self._output_dir:
+      self._summary_writer = SummaryWriterCache.get(self._output_dir)
+    self._next_step = None
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError(
+          "Global step should be created to use SummarySaverHook.")
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    self._request_summary = (
+        self._next_step is None or
+        self._timer.should_trigger_for_step(self._next_step))
+    requests = {"global_step": self._global_step_tensor}
+    if self._request_summary:
+      if self._get_summary_op() is not None:
+        requests["summary"] = self._get_summary_op()
+
+    return SessionRunArgs(requests)
+
+  def after_run(self, run_context, run_values):
+    _ = run_context
+    if not self._summary_writer:
+      return
+
+    stale_global_step = run_values.results["global_step"]
+    global_step = stale_global_step + 1
+    if self._next_step is None or self._request_summary:
+      global_step = run_context.session.run(self._global_step_tensor)
+
+    if self._next_step is None:
+      self._summary_writer.add_session_log(
+          SessionLog(status=SessionLog.START), global_step)
+
+    if self._request_summary:
+      self._timer.update_last_triggered_step(global_step)
+      if "summary" in run_values.results:
+        for summary in run_values.results["summary"]:
+          self._summary_writer.add_summary(summary, global_step)
+
+    self._next_step = global_step + 1
+
+  def end(self, session=None):
+    if self._summary_writer:
+      self._summary_writer.flush()
+
+  def _get_summary_op(self):
+    """Fetches the summary op either from self._summary_op or self._scaffold.
+
+    Returns:
+      Returns a list of summary `Tensor`.
+    """
+    summary_op = None
+    if self._summary_op is not None:
+      summary_op = self._summary_op
+    elif self._scaffold.summary_op is not None:
+      summary_op = self._scaffold.summary_op
+
+    if summary_op is None:
+      return None
+
+    if not isinstance(summary_op, list):
+      return [summary_op]
+    return summary_op
+
+
+@tf_export(v1=["train.GlobalStepWaiterHook"])
+class GlobalStepWaiterHook(session_run_hook.SessionRunHook):
+  """Delays execution until global step reaches `wait_until_step`.
+
+  This hook delays execution until global step reaches to `wait_until_step`. It
+  is used to gradually start workers in distributed settings. One example usage
+  would be setting `wait_until_step=int(K*log(task_id+1))` assuming that
+  task_id=0 is the chief.
+  """
+
+  def __init__(self, wait_until_step):
+    """Initializes a `GlobalStepWaiterHook`.
+
+    Args:
+      wait_until_step: an `int` shows until which global step should we wait.
+    """
+    self._wait_until_step = wait_until_step
+
+  def begin(self):
+    self._worker_is_started = False
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError(
+          "Global step should be created to use _GlobalStepWaiterHook.")
+
+  def before_run(self, run_context):
+    if self._worker_is_started:
+      return None
+
+    if self._wait_until_step <= 0:
+      self._worker_is_started = True
+      return None
+
+    logging.info("Waiting for global step %d before starting training.",
+                 self._wait_until_step)
+    last_logged_step = 0
+    while True:
+      current_step = run_context.session.run(self._global_step_tensor)
+      if current_step >= self._wait_until_step:
+        self._worker_is_started = True
+        return None
+      if current_step - last_logged_step > 1000:
+        logging.info(
+            "Waiting for global step %d before starting training. "
+            "Current step is %d.", self._wait_until_step, current_step)
+        last_logged_step = current_step
+      time.sleep(0.5)
+
+
+@tf_export(v1=["train.FinalOpsHook"])
+class FinalOpsHook(session_run_hook.SessionRunHook):
+  """A hook which evaluates `Tensors` at the end of a session."""
+
+  def __init__(self, final_ops, final_ops_feed_dict=None):
+    """Initializes `FinalOpHook` with ops to run at the end of the session.
+
+    Args:
+      final_ops: A single `Tensor`, a list of `Tensors` or a dictionary of names
+        to `Tensors`.
+      final_ops_feed_dict: A feed dictionary to use when running
+        `final_ops_dict`.
+    """
+    self._final_ops = final_ops
+    self._final_ops_feed_dict = final_ops_feed_dict
+    self._final_ops_values = None
+
+  @property
+  def final_ops_values(self):
+    return self._final_ops_values
+
+  def end(self, session):
+    if self._final_ops is not None:
+      try:
+        self._final_ops_values = session.run(
+            self._final_ops, feed_dict=self._final_ops_feed_dict)
+      except (errors.OutOfRangeError, StopIteration) as e:
+        logging.warning(
+            "An OutOfRangeError or StopIteration exception is raised by the "
+            "code in FinalOpsHook. This typically means the Ops running by the "
+            "FinalOpsHook have a dependency back to some input source, which "
+            "should not happen. For example, for metrics in "
+            "tf.estimator.Estimator, all metrics functions return two Ops: "
+            "`value_op` and  `update_op`. Estimator.evaluate calls the "
+            "`update_op` for each batch of the data in input source and, once "
+            "it is exhausted, it call the `value_op` to get the metric values. "
+            "The `value_op` here should have dependency back to variables "
+            "reading only, rather than reading another batch from input. "
+            "Otherwise, the `value_op`, executed by `FinalOpsHook`, triggers "
+            "another data reading, which ends OutOfRangeError/StopIteration. "
+            "Please fix that.")
+        raise e
+
+
+@tf_export(v1=["train.FeedFnHook"])
+class FeedFnHook(session_run_hook.SessionRunHook):
+  """Runs `feed_fn` and sets the `feed_dict` accordingly."""
+
+  def __init__(self, feed_fn):
+    """Initializes a `FeedFnHook`.
+
+    Args:
+      feed_fn: function that takes no arguments and returns `dict` of `Tensor`
+        to feed.
+    """
+    self.feed_fn = feed_fn
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    return session_run_hook.SessionRunArgs(
+        fetches=None, feed_dict=self.feed_fn())
+
+
+@tf_export(v1=["train.ProfilerHook"])
+class ProfilerHook(session_run_hook.SessionRunHook):
+  """Captures CPU/GPU profiling information every N steps or seconds.
+
+  This produces files called "timeline-<step>.json", which are in Chrome
+  Trace format.
+
+  For more information see:
+  https://github.com/catapult-project/catapult/blob/master/tracing/README.md
+  """
+
+  def __init__(self,
+               save_steps=None,
+               save_secs=None,
+               output_dir="",
+               show_dataflow=True,
+               show_memory=False):
+    """Initializes a hook that takes periodic profiling snapshots.
+
+    `options.run_metadata` argument of `tf.Session.Run` is used to collect
+    metadata about execution. This hook sets the metadata and dumps it in Chrome
+    Trace format.
+
+
+    Args:
+      save_steps: `int`, save profile traces every N steps. Exactly one of
+        `save_secs` and `save_steps` should be set.
+      save_secs: `int` or `float`, save profile traces every N seconds.
+      output_dir: `string`, the directory to save the profile traces to.
+        Defaults to the current directory.
+      show_dataflow: `bool`, if True, add flow events to the trace connecting
+        producers and consumers of tensors.
+      show_memory: `bool`, if True, add object snapshot events to the trace
+        showing the sizes and lifetimes of tensors.
+    """
+    self._output_file = os.path.join(output_dir, "timeline-{}.json")
+    self._file_writer = SummaryWriterCache.get(output_dir)
+    self._show_dataflow = show_dataflow
+    self._show_memory = show_memory
+    self._timer = SecondOrStepTimer(
+        every_secs=save_secs, every_steps=save_steps)
+
+  def begin(self):
+    self._next_step = None
+    self._global_step_tensor = training_util._get_or_create_global_step_read()  # pylint: disable=protected-access
+    if self._global_step_tensor is None:
+      raise RuntimeError("Global step should be created to use ProfilerHook.")
+
+  def before_run(self, run_context):
+    self._request_summary = (
+        self._next_step is not None and
+        self._timer.should_trigger_for_step(self._next_step))
+    requests = {"global_step": self._global_step_tensor}
+    opts = (
+        config_pb2.RunOptions(trace_level=config_pb2.RunOptions.FULL_TRACE)
+        if self._request_summary else None)
+
+    return SessionRunArgs(requests, options=opts)
+
+  def after_run(self, run_context, run_values):
+    stale_global_step = run_values.results["global_step"]
+    if self._next_step is None:
+      # Update the timer so that it does not activate until N steps or seconds
+      # have passed.
+      self._timer.update_last_triggered_step(stale_global_step)
+    global_step = stale_global_step + 1
+    if self._request_summary:
+      global_step = run_context.session.run(self._global_step_tensor)
+      self._timer.update_last_triggered_step(global_step)
+      self._save(global_step, self._output_file.format(global_step),
+                 run_values.run_metadata.step_stats)
+      self._file_writer.add_run_metadata(run_values.run_metadata,
+                                         "step_%d" % global_step)
+
+    self._next_step = global_step + 1
+
+  def _save(self, step, save_path, step_stats):
+    logging.info("Saving timeline for %d into '%s'.", step, save_path)
+    with gfile.Open(save_path, "w") as f:
+      trace = timeline.Timeline(step_stats)
+      f.write(
+          trace.generate_chrome_trace_format(
+              show_dataflow=self._show_dataflow, show_memory=self._show_memory))
+
+
+def _as_graph_element(obj):
+  """Retrieves Graph element."""
+  graph = ops.get_default_graph()
+  if not isinstance(obj, str):
+    if not hasattr(obj, "graph") or obj.graph != graph:
+      raise ValueError("Passed %s should have graph attribute that is equal "
+                       "to current graph %s." % (obj, graph))
+    return obj
+  if ":" in obj:
+    element = graph.as_graph_element(obj)
+  else:
+    element = graph.as_graph_element(obj + ":0")
+    # Check that there is no :1 (e.g. it's single output).
+    try:
+      graph.as_graph_element(obj + ":1")
+    except (KeyError, ValueError):
+      pass
+    else:
+      raise ValueError("Name %s is ambiguous, "
+                       "as this `Operation` has multiple outputs "
+                       "(at least 2)." % obj)
+  return element

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/checkpoint_management.py

@@ -0,0 +1,26 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+# pylint: disable=invalid-name
+"""Save and restore variables."""
+
+
+# TODO(kathywu): Delete this file after all imports have been moved to the path
+# below.
+from tensorflow.python.checkpoint import checkpoint_management
+from tensorflow.python.util import deprecation
+
+__getattr__ = deprecation.deprecate_moved_module(
+    __name__, checkpoint_management, "2.9")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/checkpoint_ops.py

@@ -0,0 +1,482 @@
+# 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.
+# ==============================================================================
+"""Operations for generating and loading vocab remappings."""
+import math
+
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import gen_checkpoint_ops
+from tensorflow.python.ops import init_ops
+from tensorflow.python.ops import math_ops
+
+ops.NotDifferentiable("GenerateVocabRemapping")
+ops.NotDifferentiable("LoadAndRemapMatrix")
+
+
+def _load_and_remap_matrix(ckpt_path,
+                           old_tensor_name,
+                           new_row_vocab_offset,
+                           num_rows_to_load,
+                           new_col_vocab_size,
+                           initializer,
+                           old_row_vocab_size=-1,
+                           old_row_vocab_file=None,
+                           new_row_vocab_file=None,
+                           old_col_vocab_file=None,
+                           new_col_vocab_file=None,
+                           num_row_oov_buckets=0,
+                           num_col_oov_buckets=0,
+                           max_rows_in_memory=-1):
+  """Loads a 2-D (matrix) `Tensor` from checkpoint.
+
+  Generates 1D-remappings for rows and columns using the
+  `GenerateVocabRemapping` op, and initializes any anticipated values with the
+  provided initializer. Then, uses the `LoadAndRemapMatrix` op to create a
+  matrix that loads existing values from the checkpoint, while filling out
+  "missing" values with the newly initialized values. See
+  contrib/framework/ops/checkpoint_ops.cc for more information on the wrapped
+  functionality (LoadAndRemapMatrix). This wrapper can be used to perform only
+  row remapping or only col remapping. If only row remapping is desired,
+  {new,old}_col_vocab_file should be `None`, and vice versa for column
+  remapping.
+
+  NOTE: This only supports div-partitioning the vocabulary on the 1st dimension
+  (row axis) via `new_row_vocab_offset`.
+
+  Args:
+    ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`)
+      from which the old matrix `Tensor` will be loaded.
+    old_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
+    new_row_vocab_offset: A 0-indexed integer representing what line to
+      start reading at in the new row vocabulary. Used for partitioned
+      variables.
+    num_rows_to_load: Number of rows to load for the new vocabulary (note: to
+      support variable partitioning and partial loading, this does not need to
+      be the same as the number of entries in `new_row_vocab_file`).
+    new_col_vocab_size: Number of columns to load - should be the same as the
+      number of entries in `new_col_vocab_file`, since we don't support
+      partitioning along the column axis.
+    initializer: Callable initializer function that accepts a 1-D tensor as the
+      arg to specify the shape of the returned tensor. Used to initialize
+      missing values.
+    old_row_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_row_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.  NOTE: we do not provide an equivalent
+      `old_col_vocab_size` for classes.
+    old_row_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the old row vocabulary file. Can be None, which represents no
+      remapping on the row axis.
+    new_row_vocab_file: A scalar `Tensor` of type `string` containing the path
+      to the new row vocabulary file. Can be None, which represents no remapping
+      on the row axis - in which case, `new_row_vocab_offset` and
+      `num_rows_to_load` work under the assumption that the new row vocab is the
+      same as the old row vocab.
+    old_col_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the old column vocabulary file. Can be None, which represents no
+      remapping on the column axis.
+    new_col_vocab_file: A scalar `Tensor` of type `string` containing the path
+      to the new column vocabulary file. Can be None, which represents no
+      remapping on the column axis - in which case, `new_col_vocab_size` works
+      under the assumption that the new col vocab is the same as the old col
+      vocab.
+    num_row_oov_buckets: `int` specifying the number of out-of-vocabulary rows
+      to append. Must be >= 0.
+    num_col_oov_buckets: `int` specifying the number of out-of-vocabulary
+      columns to append. Must be >= 0.
+    max_rows_in_memory: `int` specifying the maximum number of rows to load from
+      the checkpoint at once. If less than or equal to 0, the entire matrix will
+      be loaded into memory. Setting this arg trades increased disk reads for
+      lower memory usage.
+
+  Returns:
+    A Tensor of shape `[num_rows_to_load + num_row_oov_buckets,
+    new_col_vocab_size + num_col_oov_buckets]`, with values loaded from the
+    specified tensor in the checkpoint, and any missing or OOV values
+    initialized with the given `initializer`.
+
+  Raises:
+    ValueError: If `num_row_oov_buckets` or `num_col_oov_buckets` < 0.
+    ValueError: If either `old_row_vocab_file` or `new_row_vocab_file` is
+      provided, while the other is not. Same for `old_col_vocab_file` and
+      `new_col_vocab_file`.
+    ValueError: If neither row vocabs or col vocabs are provided.
+  """
+  if num_row_oov_buckets < 0:
+    raise ValueError("num_row_oov_buckets must be >= 0, but received %d" %
+                     num_row_oov_buckets)
+  if num_col_oov_buckets < 0:
+    raise ValueError("num_col_oov_buckets must be >= 0, but received %d" %
+                     num_col_oov_buckets)
+
+  if bool(old_row_vocab_file) != bool(new_row_vocab_file):
+    raise ValueError(
+        "old_row_vocab_file and new_row_vocab_file must both be specified or "
+        "left unspecified. old_row_vocab_file='{}', new_row_vocab_file='{}'".
+        format(old_row_vocab_file, new_row_vocab_file))
+  if bool(old_col_vocab_file) != bool(new_col_vocab_file):
+    raise ValueError(
+        "old_col_vocab_file and new_col_vocab_file must both be specified or "
+        "left unspecified. old_col_vocab_file='{}', new_col_vocab_file='{}'".
+        format(old_col_vocab_file, new_col_vocab_file))
+
+  remap_rows = new_row_vocab_file and old_row_vocab_file
+  remap_cols = new_col_vocab_file and old_col_vocab_file
+  if not (remap_rows or remap_cols):
+    raise ValueError(
+        "Must provide either row or column vocab files. If no remapping is "
+        "necessary, consider using `tf.contrib.framework.init_from_checkpoint` "
+        "instead.")
+
+  num_rows_present = num_rows_to_load
+  if remap_rows:
+    row_remapping, num_rows_present = (
+        gen_checkpoint_ops.generate_vocab_remapping(
+            new_vocab_file=new_row_vocab_file,
+            old_vocab_file=old_row_vocab_file,
+            new_vocab_offset=new_row_vocab_offset,
+            num_new_vocab=num_rows_to_load,
+            old_vocab_size=old_row_vocab_size))
+  else:
+    # Even when the rows are not being reordered, we still need to generate a
+    # remapping to account for initializing partitioned Variables (when
+    # new_row_vocab_offset is non-zero).
+    row_remapping = math_ops.range(
+        new_row_vocab_offset,
+        new_row_vocab_offset + num_rows_to_load,
+        dtype=dtypes.int64)
+
+  col_remapping = []
+  num_cols_present = new_col_vocab_size
+  if remap_cols:
+    col_remapping, num_cols_present = (
+        gen_checkpoint_ops.generate_vocab_remapping(
+            new_vocab_file=new_col_vocab_file,
+            old_vocab_file=old_col_vocab_file,
+            new_vocab_offset=0,  # Offset is unused for cols (no partitioning).
+            num_new_vocab=new_col_vocab_size))
+
+  init_vals = initializer([
+      num_rows_to_load * new_col_vocab_size -
+      num_rows_present * num_cols_present, 1
+  ])
+  return_tensor = gen_checkpoint_ops.load_and_remap_matrix(
+      ckpt_path=ckpt_path,
+      old_tensor_name=old_tensor_name,
+      row_remapping=row_remapping,
+      col_remapping=col_remapping,
+      initializing_values=init_vals,
+      num_rows=num_rows_to_load,
+      num_cols=new_col_vocab_size,
+      max_rows_in_memory=max_rows_in_memory)
+
+  # Add OOV row(s) and column(s).
+  if num_row_oov_buckets > 0:
+    init_row_oov_val = initializer([num_row_oov_buckets, new_col_vocab_size])
+    init_row_oov_val = ops.convert_to_tensor(init_row_oov_val)
+    return_tensor = array_ops.concat([return_tensor, init_row_oov_val], 0)
+  if num_col_oov_buckets > 0:
+    # We need to add any row OOV to the new column shape.
+    init_col_oov_val = initializer(
+        [num_rows_to_load + num_row_oov_buckets, num_col_oov_buckets])
+    init_col_oov_val = ops.convert_to_tensor(init_col_oov_val)
+    return_tensor = array_ops.concat([return_tensor, init_col_oov_val], 1)
+
+  return return_tensor
+
+
+def _load_and_remap_matrix_initializer(ckpt_path,
+                                       old_tensor_name,
+                                       new_row_vocab_size,
+                                       new_col_vocab_size,
+                                       old_row_vocab_size=-1,
+                                       old_row_vocab_file=None,
+                                       new_row_vocab_file=None,
+                                       old_col_vocab_file=None,
+                                       new_col_vocab_file=None,
+                                       num_row_oov_buckets=0,
+                                       num_col_oov_buckets=0,
+                                       initializer=None,
+                                       max_rows_in_memory=-1):
+  r"""Returns a var initializer for loading and remapping a 2-D (matrix) tensor.
+
+  The returned initializer loads a 2-D (matrix) `Tensor` with name
+  `old_tensor_name` from the checkpoint at `ckpt_path`. It will reorder the
+  rows/columns according to the specified vocab files and append additional
+  out-of-vocabulary rows/columns according to the number of OOV buckets.
+
+  The format of the file at the `{old,new}_{row,col}_vocab_file` path should be
+  a text file, with each line containing a single entity within the vocabulary.
+  Let the function `line_of(f, "x")` return the 0-indexed line number of the
+  entity "x" in file f, and the function `entity_at(f, i)` return the entity at
+  line i of file f. Then, row i of the new output matrix will be taken from row
+  `line_of(old_row_vocab_file, entity_at(new_row_vocab_file, i))` of the old
+  matrix. If any entity in `new_row_vocab_file` is not found in
+  `old_row_vocab_file`, that row is considered a "missing" row, and its values
+  will be initialized using the `initializer` arg. The same logic also applies
+  for the columns.
+
+  For example, assuming that:
+
+  * `old_row_vocab_file` contains "mercury\nvenus\nmars"
+  * `new_row_vocab_file` contains "venus\njupiter\nmercury"
+  * `old_col_vocab_file` contains "good\nbetter\nbest"
+  * `new_col_vocab_file` contains "good\nbest\nfantastic"
+  * `initializer` returns the natural numbers `[1, 2, 3, 4, ...]`
+  * `w(i, j)` represents the value from row i, column j of the old matrix
+
+  Then the new output matrix will look like:
+
+  `[[w(1, 0), w(1, 2), 1],
+    [2,       3,       4],
+    [w(0, 0), w(0, 2), 5]]`
+
+  If we further specify that:
+
+  * `num_row_oov_buckets` == 2
+  * `num_col_oov_buckets` == 1
+
+  Then the new output matrix will look like:
+
+  `[[w(1, 0), w(1, 2), 1,  12],
+    [2,       3,       4,  13],
+    [w(0, 0), w(0, 2), 5,  14],
+    [6,       7,       8,  15],
+    [9,       10,      11, 16]]`
+
+  If `{old,new}_row_vocab_file` are None, we assume that the old and new row
+  vocab files are the same, and no row remapping is done. If
+  `{old,new}_col_vocab_file` are None, we assume that the old and new column
+  vocab files are the same, and no column remapping is done.
+
+  The returned initializer only supports div-partitioning along the row axis. It
+  does not support partitioning along the column axis (as this is not common in
+  practice) or mod-partitioning.
+
+  NOTE: When this is used to warm-start variables, client code should use
+  `tf.lookup.index_table_from_tensor()` like
+  contrib/layers/python/layers/feature_column.py does, as opposed to
+  `tf.feature_to_id()` - in order to ensure the underlying lookup tables are the
+  same.
+
+  Args:
+    ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`)
+      from which the old matrix `Tensor` will be loaded.
+    old_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
+    new_row_vocab_size: `int` specifying the number of entries in
+      `new_row_vocab_file`. If no row remapping is needed (no row vocab
+      provided), this should be equal to the number of rows to load from the old
+      matrix (which can theoretically be smaller than the number of rows in the
+      old matrix).
+    new_col_vocab_size: `int` specifying the number of entries in
+      `new_col_vocab_file`. If no column remapping is needed (no column vocab
+      provided), this should be equal to the number of columns in the old
+      matrix.
+    old_row_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_row_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.  NOTE: we do not provide an equivalent
+      `old_col_vocab_size` for classes.
+    old_row_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the old row vocabulary file. Can be None, which represents no
+      remapping on the row axis.
+    new_row_vocab_file: A scalar `Tensor` of type `string` containing the path
+      to the new row vocabulary file. Can be None, which represents no remapping
+      on the row axis.
+    old_col_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the old column vocabulary file. Can be None, which represents no
+      remapping on the column axis.
+    new_col_vocab_file: A scalar `Tensor` of type `string` containing the path
+      to the new column vocabulary file. Can be None, which represents no
+      remapping on the column axis.
+    num_row_oov_buckets: `int` specifying the number of out-of-vocabulary rows
+      to append. Must be >= 0.
+    num_col_oov_buckets: `int` specifying the number of out-of-vocabulary
+      columns to append. Must be >= 0.
+    initializer: Initializer function to initialize missing values. Accepts a
+      1-D tensor as the arg to specify the shape of the returned tensor. If
+      `None`, defaults to using `zeros_initializer()`.
+    max_rows_in_memory: `int` specifying the maximum number of rows to load from
+      the checkpoint at once. If less than or equal to 0, the entire matrix will
+      be loaded into memory. Setting this arg trades increased disk reads for
+      lower memory usage.
+
+  Returns:
+    A variable initializer function that should be used to initialize a
+    (potentially partitioned) `Variable` whose complete shape is
+    `[new_row_vocab_size + num_row_oov_buckets, new_col_vocab_size +
+    num_col_oov_buckets]`.
+
+  Raises:
+    TypeError: If `initializer` is specified but not callable.
+  """
+  if initializer is None:
+    # TODO(b/25671353): Consider using sqrt(6/(fan_in + fan_out)) instead, from
+    # Glorot and Bengio, 2010.
+    initializer = init_ops.zeros_initializer()
+
+  if not callable(initializer):
+    raise TypeError(
+        "initializer must be callable, instead of being {} of type {}.".format(
+            initializer, type(initializer)))
+
+  def _initializer(shape, dtype=dtypes.float32, partition_info=None):
+    """Variable initializer.
+
+    Args:
+      shape: Shape of `Tensor` to return. Should include OOV on both axes.
+      dtype: Must be float32.
+      partition_info: variable_scope._PartitionInfo.
+
+    Returns:
+      `Tensor` of shape `shape`.
+
+    Raises:
+      TypeError: If `dtype` is anything other than float32.
+      ValueError: For shape mismatch upon invocation.
+    """
+    # Sanity checks.
+    if dtype != dtypes.float32:
+      raise TypeError(
+          "Currently, only float32 is supported. Received dtype: {}".format(
+              dtype))
+    if len(shape) != 2:
+      raise ValueError("Expected 2-dim shape, but received: {}".format(shape))
+    if shape[0] <= 0:
+      raise ValueError(
+          "Expected 1st dim of shape to be > 0, but received shape: {}".format(
+              shape))
+    if shape[1] != (new_col_vocab_size + num_col_oov_buckets):
+      raise ValueError(
+          "Expected 2nd dim of shape to be new_col_vocab_size ({}) + "
+          "num_col_oov_buckets ({}) = {}, but received shape: {}".format(
+              new_col_vocab_size, num_col_oov_buckets,
+              new_col_vocab_size + num_col_oov_buckets, shape))
+
+    offset = 0
+    if partition_info is not None:
+      offset = partition_info.single_offset(shape)
+
+    if offset + shape[0] > new_row_vocab_size + num_row_oov_buckets:
+      raise ValueError(
+          "Trying to initialize {} additional rows after {} rows have already "
+          "been initialized, which would exceed expected total row count of "
+          "new_row_vocab_size ({}) + num_row_oov_buckets ({}) = {}.".format(
+              shape[0], offset, new_row_vocab_size, num_row_oov_buckets,
+              new_row_vocab_size + num_row_oov_buckets))
+
+    row_oov_buckets_to_use = min(shape[0],
+                                 max(0, offset + shape[0] - new_row_vocab_size))
+    num_rows_to_load = shape[0] - row_oov_buckets_to_use
+
+    # We may be operating on an OOV-only partition, in which case we newly
+    # initialize all rows of this partition.
+    if offset > new_row_vocab_size:
+      if shape[0] != row_oov_buckets_to_use:
+        raise ValueError(
+            "Partitioned variable offset is greater than new vocab size and "
+            "not operating on OOV-only partition.")
+      return initializer(shape)
+
+    return _load_and_remap_matrix(
+        ckpt_path=ckpt_path,
+        old_tensor_name=old_tensor_name,
+        new_row_vocab_offset=offset,
+        num_rows_to_load=num_rows_to_load,
+        new_col_vocab_size=new_col_vocab_size,
+        initializer=initializer,
+        old_row_vocab_size=old_row_vocab_size,
+        old_row_vocab_file=old_row_vocab_file,
+        new_row_vocab_file=new_row_vocab_file,
+        old_col_vocab_file=old_col_vocab_file,
+        new_col_vocab_file=new_col_vocab_file,
+        num_row_oov_buckets=row_oov_buckets_to_use,
+        num_col_oov_buckets=num_col_oov_buckets,
+        max_rows_in_memory=max_rows_in_memory)
+
+  return _initializer
+
+
+def _load_embedding_initializer(ckpt_path,
+                                embedding_tensor_name,
+                                new_vocab_size,
+                                embedding_dim,
+                                old_vocab_file,
+                                new_vocab_file,
+                                old_vocab_size=-1,
+                                num_oov_buckets=0,
+                                initializer=None,
+                                max_rows_in_memory=-1):
+  """Returns a variable initializer for loading pre-trained embeddings.
+
+  Wrapper around `load_and_remap_matrix_initializer()` specialized for loading
+  embedding weights and remapping according to the provided vocab files. See
+  docs for `load_and_remap_matrix_initializer()` for more details.
+
+  NOTE: Only for use with div-partitioned variables / vocabularies.
+
+  Args:
+    ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`)
+      from which the old matrix `Tensor` will be loaded.
+    embedding_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
+    new_vocab_size: Number of entries in the new vocab.
+    embedding_dim: `int` specifying the dimension of the embedding vectors from
+      the checkpoint. Must match the number of columns in the old embedding
+      matrix.
+    old_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the old vocabulary file.
+    new_vocab_file: A scalar `Tensor` of type `string` containing the
+      path to the new vocabulary file.
+    old_vocab_size: The number of entries to consider in the old vocabulary.
+      With the default value of -1, the entire old row vocabulary file will be
+      used.  Otherwise, only the first `old_vocab_size` entries will be
+      considered for remapping.Must be smaller than the length of
+      `old_row_vocab_file`.
+    num_oov_buckets: `int` specifying the number of out-of-vocabulary
+      buckets to use. Must be >= 0.
+    initializer: Initializer function that accepts a 1-D tensor as the arg to
+      specify the shape of the returned tensor. If `None`, defaults to using
+      `truncated_normal_initializer()`.
+    max_rows_in_memory: `int` specifying the maximum number of rows to load from
+      the checkpoint at once. If less than or equal to 0, the entire matrix will
+      be loaded into memory. Setting this arg trades increased disk reads for
+      lower memory usage.
+
+  Returns:
+    A variable initializer function.
+  """
+  if initializer is None:
+    # TODO(b/25671353): This should be kept in sync with the stddev used by
+    # feature_column.py's _EmbeddingColumn.
+    initializer = init_ops.truncated_normal_initializer(
+        stddev=1.0 / math.sqrt(embedding_dim))
+
+  return _load_and_remap_matrix_initializer(
+      ckpt_path=ckpt_path,
+      old_tensor_name=embedding_tensor_name,
+      new_row_vocab_size=new_vocab_size,
+      new_col_vocab_size=embedding_dim,
+      old_row_vocab_size=old_vocab_size,
+      old_row_vocab_file=old_vocab_file,
+      new_row_vocab_file=new_vocab_file,
+      old_col_vocab_file=None,
+      new_col_vocab_file=None,
+      num_row_oov_buckets=num_oov_buckets,
+      num_col_oov_buckets=0,
+      initializer=initializer,
+      max_rows_in_memory=max_rows_in_memory)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/checkpoint_state_pb2.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/python/training/checkpoint_state.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n1tensorflow/python/training/checkpoint_state.proto\x12\ntensorflow\"\x9f\x01\n\x0f\x43heckpointState\x12\x1d\n\x15model_checkpoint_path\x18\x01 \x01(\t\x12\"\n\x1a\x61ll_model_checkpoint_paths\x18\x02 \x03(\t\x12\'\n\x1f\x61ll_model_checkpoint_timestamps\x18\x03 \x03(\x01\x12 \n\x18last_preserved_timestamp\x18\x04 \x01(\x01\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.python.training.checkpoint_state_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _CHECKPOINTSTATE._serialized_start=66
+  _CHECKPOINTSTATE._serialized_end=225
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/checkpoint_utils.py

@@ -0,0 +1,571 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tools to work with name-based checkpoints.
+
+While some of these symbols also work with the TF2 object-based checkpoints,
+they are not recommended for TF2. Please check  `tensorflow/python/checkpoint`
+for newer utilities built to work with TF2 checkpoints.
+"""
+
+from collections import abc
+import os
+import time
+
+from tensorflow.python.checkpoint import checkpoint_management
+from tensorflow.python.distribute import distribute_lib
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import io_ops
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.ops import variable_scope as vs
+from tensorflow.python.ops import variables
+from tensorflow.python.platform import gfile
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.training import py_checkpoint_reader
+from tensorflow.python.training.saving import saveable_object_util
+from tensorflow.python.util.tf_export import tf_export
+
+
+__all__ = [
+    "load_checkpoint", "load_variable", "list_variables",
+    "checkpoints_iterator", "init_from_checkpoint"
+]
+
+
+@tf_export("train.load_checkpoint")
+def load_checkpoint(ckpt_dir_or_file):
+  """Returns `CheckpointReader` for checkpoint found in `ckpt_dir_or_file`.
+
+  If `ckpt_dir_or_file` resolves to a directory with multiple checkpoints,
+  reader for the latest checkpoint is returned.
+
+  Example usage:
+
+  ```python
+  import tensorflow as tf
+  a = tf.Variable(1.0)
+  b = tf.Variable(2.0)
+  ckpt = tf.train.Checkpoint(var_list={'a': a, 'b': b})
+  ckpt_path = ckpt.save('tmp-ckpt')
+  reader= tf.train.load_checkpoint(ckpt_path)
+  print(reader.get_tensor('var_list/a/.ATTRIBUTES/VARIABLE_VALUE'))  # 1.0
+  ```
+
+  Args:
+    ckpt_dir_or_file: Directory with checkpoints file or path to checkpoint
+      file.
+
+  Returns:
+    `CheckpointReader` object.
+
+  Raises:
+    ValueError: If `ckpt_dir_or_file` resolves to a directory with no
+      checkpoints.
+  """
+  filename = _get_checkpoint_filename(ckpt_dir_or_file)
+  if filename is None:
+    raise ValueError("Couldn't find 'checkpoint' file or checkpoints in "
+                     "given directory %s" % ckpt_dir_or_file)
+  return py_checkpoint_reader.NewCheckpointReader(filename)
+
+
+@tf_export("train.load_variable")
+def load_variable(ckpt_dir_or_file, name):
+  """Returns the tensor value of the given variable in the checkpoint.
+
+  When the variable name is unknown, you can use `tf.train.list_variables` to
+  inspect all the variable names.
+
+  Example usage:
+
+  ```python
+  import tensorflow as tf
+  a = tf.Variable(1.0)
+  b = tf.Variable(2.0)
+  ckpt = tf.train.Checkpoint(var_list={'a': a, 'b': b})
+  ckpt_path = ckpt.save('tmp-ckpt')
+  var= tf.train.load_variable(
+      ckpt_path, 'var_list/a/.ATTRIBUTES/VARIABLE_VALUE')
+  print(var)  # 1.0
+  ```
+
+  Args:
+    ckpt_dir_or_file: Directory with checkpoints file or path to checkpoint.
+    name: Name of the variable to return.
+
+  Returns:
+    A numpy `ndarray` with a copy of the value of this variable.
+  """
+  # TODO(b/29227106): Fix this in the right place and remove this.
+  if name.endswith(":0"):
+    name = name[:-2]
+  reader = load_checkpoint(ckpt_dir_or_file)
+  return reader.get_tensor(name)
+
+
+@tf_export("train.list_variables")
+def list_variables(ckpt_dir_or_file):
+  """Lists the checkpoint keys and shapes of variables in a checkpoint.
+
+  Checkpoint keys are paths in a checkpoint graph.
+
+  Example usage:
+
+  ```python
+  import tensorflow as tf
+  import os
+  ckpt_directory = "/tmp/training_checkpoints/ckpt"
+  ckpt = tf.train.Checkpoint(optimizer=optimizer, model=model)
+  manager = tf.train.CheckpointManager(ckpt, ckpt_directory, max_to_keep=3)
+  train_and_checkpoint(model, manager)
+  tf.train.list_variables(manager.latest_checkpoint)
+  ```
+
+  Args:
+    ckpt_dir_or_file: Directory with checkpoints file or path to checkpoint.
+
+  Returns:
+    List of tuples `(key, shape)`.
+  """
+  reader = load_checkpoint(ckpt_dir_or_file)
+  variable_map = reader.get_variable_to_shape_map()
+  names = sorted(variable_map.keys())
+  result = []
+  for name in names:
+    result.append((name, variable_map[name]))
+  return result
+
+
+def wait_for_new_checkpoint(checkpoint_dir,
+                            last_checkpoint=None,
+                            seconds_to_sleep=1,
+                            timeout=None):
+  """Waits until a new checkpoint file is found.
+
+  Args:
+    checkpoint_dir: The directory in which checkpoints are saved.
+    last_checkpoint: The last checkpoint path used or `None` if we're expecting
+      a checkpoint for the first time.
+    seconds_to_sleep: The number of seconds to sleep for before looking for a
+      new checkpoint.
+    timeout: The maximum number of seconds to wait. If left as `None`, then the
+      process will wait indefinitely.
+
+  Returns:
+    a new checkpoint path, or None if the timeout was reached.
+  """
+  logging.info("Waiting for new checkpoint at %s", checkpoint_dir)
+  stop_time = time.time() + timeout if timeout is not None else None
+  while True:
+    checkpoint_path = checkpoint_management.latest_checkpoint(checkpoint_dir)
+    if checkpoint_path is None or checkpoint_path == last_checkpoint:
+      if stop_time is not None and time.time() + seconds_to_sleep > stop_time:
+        return None
+      time.sleep(seconds_to_sleep)
+    else:
+      logging.info("Found new checkpoint at %s", checkpoint_path)
+      return checkpoint_path
+
+
+@tf_export("train.checkpoints_iterator")
+def checkpoints_iterator(checkpoint_dir,
+                         min_interval_secs=0,
+                         timeout=None,
+                         timeout_fn=None):
+  """Continuously yield new checkpoint files as they appear.
+
+  The iterator only checks for new checkpoints when control flow has been
+  reverted to it. This means it can miss checkpoints if your code takes longer
+  to run between iterations than `min_interval_secs` or the interval at which
+  new checkpoints are written.
+
+  The `timeout` argument is the maximum number of seconds to block waiting for
+  a new checkpoint.  It is used in combination with the `timeout_fn` as
+  follows:
+
+  * If the timeout expires and no `timeout_fn` was specified, the iterator
+    stops yielding.
+  * If a `timeout_fn` was specified, that function is called and if it returns
+    a true boolean value the iterator stops yielding.
+  * If the function returns a false boolean value then the iterator resumes the
+    wait for new checkpoints.  At this point the timeout logic applies again.
+
+  This behavior gives control to callers on what to do if checkpoints do not
+  come fast enough or stop being generated.  For example, if callers have a way
+  to detect that the training has stopped and know that no new checkpoints
+  will be generated, they can provide a `timeout_fn` that returns `True` when
+  the training has stopped.  If they know that the training is still going on
+  they return `False` instead.
+
+  Args:
+    checkpoint_dir: The directory in which checkpoints are saved.
+    min_interval_secs: The minimum number of seconds between yielding
+      checkpoints.
+    timeout: The maximum number of seconds to wait between checkpoints. If left
+      as `None`, then the process will wait indefinitely.
+    timeout_fn: Optional function to call after a timeout.  If the function
+      returns True, then it means that no new checkpoints will be generated and
+      the iterator will exit.  The function is called with no arguments.
+
+  Yields:
+    String paths to latest checkpoint files as they arrive.
+  """
+  checkpoint_path = None
+  while True:
+    new_checkpoint_path = wait_for_new_checkpoint(
+        checkpoint_dir, checkpoint_path, timeout=timeout)
+    if new_checkpoint_path is None:
+      if not timeout_fn:
+        # timed out
+        logging.info("Timed-out waiting for a checkpoint.")
+        return
+      if timeout_fn():
+        # The timeout_fn indicated that we are truly done.
+        return
+      else:
+        # The timeout_fn indicated that more checkpoints may come.
+        continue
+    start = time.time()
+    checkpoint_path = new_checkpoint_path
+    yield checkpoint_path
+    time_to_next_eval = start + min_interval_secs - time.time()
+    if time_to_next_eval > 0:
+      time.sleep(time_to_next_eval)
+
+
+@tf_export(v1=["train.init_from_checkpoint"])
+def init_from_checkpoint(ckpt_dir_or_file, assignment_map):
+  """Replaces `tf.Variable` initializers so they load from a checkpoint file.
+
+  @compatibility(TF2)
+  `tf.compat.v1.train.init_from_checkpoint` is not recommended for restoring
+  variable values in TF2.
+
+  To restore checkpoints in TF2, please use
+  `tf.keras.Model.load_weights` or `tf.train.Checkpoint.restore`. These APIs use
+  use an [object-based method of checkpointing]
+  (https://www.tensorflow.org/guide/checkpoint#loading_mechanics), while
+  `tf.compat.v1.init_from_checkpoint` relies on a more-fragile variable-name
+  based method of checkpointing. There is no object-based equivalent of
+  `init_from_checkpoint` in TF2.
+
+  Please re-write your checkpoints immediately using the object-based APIs,
+  see [migration guide]
+  (https://www.tensorflow.org/guide/migrate#checkpoint_compatibility) for more
+  details.
+
+  You can load a name-based checkpoint written by `tf.compat.v1.train.Saver`
+  using `tf.train.Checkpoint.restore` or `tf.keras.Model.load_weights`. However,
+  you may have to change the names of the variables in your model to match the
+  variable names in the name-based checkpoint, which can be viewed with
+  `tf.train.list_variables(path)`.
+
+  Another option is to create an `assignment_map` that maps the name of the
+  variables in the name-based checkpoint to the variables in your model, eg:
+  ```
+  {
+      'sequential/dense/bias': model.variables[0],
+      'sequential/dense/kernel': model.variables[1]
+  }
+  ```
+  and use `tf.compat.v1.train.init_from_checkpoint(path, assignment_map)` to
+  restore the name-based checkpoint.
+
+  After restoring, re-encode your checkpoint using `tf.train.Checkpoint.save`
+  or `tf.keras.Model.save_weights`.
+
+  @end_compatibility
+
+  Values are not loaded immediately, but when the initializer is run
+  (typically by running a `tf.compat.v1.global_variables_initializer` op).
+
+  Note: This overrides default initialization ops of specified variables and
+  redefines dtype.
+
+  Assignment map supports following syntax:
+
+  * `'checkpoint_scope_name/': 'scope_name/'` - will load all variables in
+    current `scope_name` from `checkpoint_scope_name` with matching tensor
+    names.
+  * `'checkpoint_scope_name/some_other_variable': 'scope_name/variable_name'` -
+    will initialize `scope_name/variable_name` variable
+    from `checkpoint_scope_name/some_other_variable`.
+  * `'scope_variable_name': variable` - will initialize given `tf.Variable`
+    object with tensor 'scope_variable_name' from the checkpoint.
+  * `'scope_variable_name': list(variable)` - will initialize list of
+    partitioned variables with tensor 'scope_variable_name' from the checkpoint.
+  * `'/': 'scope_name/'` - will load all variables in current `scope_name` from
+    checkpoint's root (e.g. no scope).
+
+  Supports loading into partitioned variables, which are represented as
+  `'<variable>/part_<part #>'`.
+
+  Assignment map can be a dict, or a list of pairs.  The latter is
+  necessary to initialize multiple variables in the current graph from
+  the same variable in the checkpoint.
+
+  Example:
+
+  ```python
+
+  # Say, '/tmp/model.ckpt' has the following tensors:
+  #  -- name='old_scope_1/var1', shape=[20, 2]
+  #  -- name='old_scope_1/var2', shape=[50, 4]
+  #  -- name='old_scope_2/var3', shape=[100, 100]
+
+  # Create new model's variables
+  with tf.compat.v1.variable_scope('new_scope_1'):
+    var1 = tf.compat.v1.get_variable('var1', shape=[20, 2],
+                           initializer=tf.compat.v1.zeros_initializer())
+  with tf.compat.v1.variable_scope('new_scope_2'):
+    var2 = tf.compat.v1.get_variable('var2', shape=[50, 4],
+                           initializer=tf.compat.v1.zeros_initializer())
+    # Partition into 5 variables along the first axis.
+    var3 = tf.compat.v1.get_variable(name='var3', shape=[100, 100],
+                           initializer=tf.compat.v1.zeros_initializer(),
+                           partitioner=lambda shape, dtype: [5, 1])
+
+  # Initialize all variables in `new_scope_1` from `old_scope_1`.
+  init_from_checkpoint('/tmp/model.ckpt', {'old_scope_1/': 'new_scope_1/'})
+
+  # Use names to specify which variables to initialize from checkpoint.
+  init_from_checkpoint('/tmp/model.ckpt',
+                       {'old_scope_1/var1': 'new_scope_1/var1',
+                        'old_scope_1/var2': 'new_scope_2/var2'})
+
+  # Or use tf.Variable objects to identify what to initialize.
+  init_from_checkpoint('/tmp/model.ckpt',
+                       {'old_scope_1/var1': var1,
+                        'old_scope_1/var2': var2})
+
+  # Initialize partitioned variables using variable's name
+  init_from_checkpoint('/tmp/model.ckpt',
+                       {'old_scope_2/var3': 'new_scope_2/var3'})
+
+  # Or specify the list of tf.Variable objects.
+  init_from_checkpoint('/tmp/model.ckpt',
+                       {'old_scope_2/var3': var3._get_variable_list()})
+
+  ```
+
+  Args:
+    ckpt_dir_or_file: Directory with checkpoints file or path to checkpoint.
+    assignment_map: Dict, or a list of key-value pairs, where keys are names
+      of the variables in the checkpoint and values are current variables or
+      names of current variables (in default graph).
+
+  Raises:
+    ValueError: If missing variables in current graph, or if missing
+      checkpoints or tensors in checkpoints.
+
+  """
+  init_from_checkpoint_fn = lambda _: _init_from_checkpoint(
+      ckpt_dir_or_file, assignment_map)
+  if distribute_lib.get_cross_replica_context():
+    init_from_checkpoint_fn(None)
+  else:
+    distribute_lib.get_replica_context().merge_call(
+        init_from_checkpoint_fn)
+
+
+def _init_from_checkpoint(ckpt_dir_or_file, assignment_map):
+  """See `init_from_checkpoint` for documentation."""
+  ckpt_file = _get_checkpoint_filename(ckpt_dir_or_file)
+  reader = load_checkpoint(ckpt_dir_or_file)
+  variable_map = reader.get_variable_to_shape_map()
+  if isinstance(assignment_map, abc.Mapping):
+    assignment_map = assignment_map.items()
+
+  # We only want to sort by tensor names.
+  sort_key = lambda pair: pair[0]
+
+  for tensor_name_in_ckpt, current_var_or_name in sorted(
+      assignment_map, key=sort_key):
+    var = None
+    # Check if this is Variable object or list of Variable objects (in case of
+    # partitioned variables).
+    if _is_variable(current_var_or_name) or (
+        isinstance(current_var_or_name, list)
+        and all(_is_variable(v) for v in current_var_or_name)):
+      var = current_var_or_name
+    else:
+      store_vars = vs._get_default_variable_store()._vars  # pylint:disable=protected-access
+      # Check if this variable is in var_store.
+      var = store_vars.get(current_var_or_name, None)
+      # Also check if variable is partitioned as list.
+      if var is None:
+        var = _collect_partitioned_variable(current_var_or_name, store_vars)
+    if var is not None:
+      # If 1 to 1 mapping was provided, find variable in the checkpoint.
+      if tensor_name_in_ckpt not in variable_map:
+        raise ValueError("Tensor %s is not found in %s checkpoint %s" % (
+            tensor_name_in_ckpt, ckpt_dir_or_file, variable_map
+        ))
+      if _is_variable(var):
+        # Additional at-call-time checks.
+        if not var.get_shape().is_compatible_with(
+            variable_map[tensor_name_in_ckpt]):
+          raise ValueError(
+              "Shape of variable %s (%s) doesn't match with shape of "
+              "tensor %s (%s) from checkpoint reader." % (
+                  var.name, str(var.get_shape()),
+                  tensor_name_in_ckpt, str(variable_map[tensor_name_in_ckpt])
+              ))
+        var_name = var.name
+      else:
+        var_name = ",".join(v.name for v in var)
+      _set_variable_or_list_initializer(var, ckpt_file, tensor_name_in_ckpt)
+      logging.debug("Initialize variable %s from checkpoint %s with %s",
+                    var_name, ckpt_dir_or_file, tensor_name_in_ckpt)
+    else:
+      scopes = ""
+      # TODO(vihanjain): Support list of 'current_var_or_name' here.
+      if "/" in current_var_or_name:
+        scopes = current_var_or_name[:current_var_or_name.rindex("/")]
+      if not tensor_name_in_ckpt.endswith("/"):
+        raise ValueError(
+            "Assignment map with scope only name {} should map to scope only "
+            "{}. Should be 'scope/': 'other_scope/'.".format(
+                scopes, tensor_name_in_ckpt))
+      # If scope to scope mapping was provided, find all variables in the scope
+      # and create variable to variable mapping.
+      scope_variables = set()
+      for var_name in store_vars:
+        if not scopes or var_name.startswith(scopes + "/"):
+          # Consume /part_ if partitioned variable.
+          if "/part_" in var_name:
+            var_name = var_name[:var_name.index("/part_")]
+          scope_variables.add(var_name)
+      for var_name in sorted(scope_variables):
+        # Lookup name with specified prefix and suffix from current variable.
+        # If tensor_name given is '/' (root), don't use it for full name.
+        full_tensor_name = var_name[len(scopes):]
+        if current_var_or_name != "/":
+          full_tensor_name = full_tensor_name[1:]
+        if tensor_name_in_ckpt != "/":
+          full_tensor_name = tensor_name_in_ckpt + full_tensor_name
+        # Remove trailing '/', if any, in the full_tensor_name
+        if full_tensor_name.endswith("/"):
+          full_tensor_name = full_tensor_name[:-1]
+        if full_tensor_name not in variable_map:
+          raise ValueError(
+              "Tensor %s (%s in %s) is not found in %s checkpoint" % (
+                  full_tensor_name, var_name[len(scopes) + 1:],
+                  tensor_name_in_ckpt, ckpt_dir_or_file
+              ))
+        var = store_vars.get(var_name, None)
+        if var is None:
+          var = _collect_partitioned_variable(var_name, store_vars)
+        _set_variable_or_list_initializer(var, ckpt_file, full_tensor_name)
+        logging.debug("Initialize variable %s from checkpoint %s with %s",
+                      var_name, ckpt_dir_or_file, full_tensor_name)
+
+
+def _get_checkpoint_filename(ckpt_dir_or_file):
+  """Returns checkpoint filename given directory or specific checkpoint file."""
+  if isinstance(ckpt_dir_or_file, os.PathLike):
+    ckpt_dir_or_file = os.fspath(ckpt_dir_or_file)
+  if gfile.IsDirectory(ckpt_dir_or_file):
+    return checkpoint_management.latest_checkpoint(ckpt_dir_or_file)
+  return ckpt_dir_or_file
+
+
+def _set_checkpoint_initializer(variable,
+                                ckpt_file,
+                                tensor_name,
+                                slice_spec,
+                                name="checkpoint_initializer"):
+  """Overrides given variable's initialization op.
+
+  Sets variable initializer to assign op that initializes variable from tensor's
+  value in the checkpoint.
+
+  Args:
+    variable: `tf.Variable` object.
+    ckpt_file: string, full path of the checkpoint.
+    tensor_name: Name of the tensor to load from the checkpoint.
+    slice_spec: Slice specification for loading partitioned tensors.
+    name: Name of the operation.
+  """
+  base_type = variable.dtype.base_dtype
+  # Do not colocate with variable since RestoreV2 op only runs on CPU and
+  # colocation will force variable (and other ops that colocate with variable)
+  # to be on CPU as well. It is okay to place the variable's initializer op on
+  # CPU since it will only be run once at the start.
+  with ops.device(variable.device), ops.device("/cpu:0"):
+    restore_op = io_ops.restore_v2(
+        ckpt_file, [tensor_name], [slice_spec], [base_type], name=name)[0]
+
+    names_to_saveables = saveable_object_util.op_list_to_dict([variable])
+    saveable_objects = []
+    for name, op in names_to_saveables.items():
+      for s in saveable_object_util.saveable_objects_for_op(op, name):
+        saveable_objects.append(s)
+
+    assert len(saveable_objects) == 1  # Should be only one variable.
+  init_op = saveable_objects[0].restore([restore_op], restored_shapes=None)
+
+  # pylint:disable=protected-access
+  variable._initializer_op = init_op
+  restore_op.set_shape(variable.shape)
+  variable._initial_value = restore_op
+  # pylint:enable=protected-access
+
+
+def _set_variable_or_list_initializer(variable_or_list, ckpt_file,
+                                      tensor_name):
+  """Overrides initialization op of given variable or list of variables.
+
+  Calls `_set_checkpoint_initializer` for each variable in the given list of
+  variables.
+
+  Args:
+    variable_or_list: `tf.Variable` object or a list of `tf.Variable` objects.
+    ckpt_file: string, full path of the checkpoint.
+    tensor_name: Name of the tensor to load from the checkpoint.
+
+  Raises:
+    ValueError: if all objects in `variable_or_list` are not partitions of the
+      same large variable.
+  """
+  if isinstance(variable_or_list, (list, tuple)):
+    # A set of slices.
+    slice_name = None
+    for v in variable_or_list:
+      slice_info = v._save_slice_info  # pylint:disable=protected-access
+      if slice_name is None:
+        slice_name = slice_info.full_name
+      elif slice_name != slice_info.full_name:
+        raise ValueError("Slices must all be from the same tensor: %s != %s" %
+                         (slice_name, slice_info.full_name))
+      _set_checkpoint_initializer(v, ckpt_file, tensor_name, slice_info.spec)
+  else:
+    _set_checkpoint_initializer(variable_or_list, ckpt_file, tensor_name, "")
+
+
+def _is_variable(x):
+  return (isinstance(x, variables.Variable) or
+          resource_variable_ops.is_resource_variable(x))
+
+
+def _collect_partitioned_variable(name, all_vars):
+  """Returns list of `tf.Variable` that comprise the partitioned variable."""
+  if name + "/part_0" in all_vars:
+    var = []
+    i = 0
+    while name + "/part_%d" % i in all_vars:
+      var.append(all_vars[name + "/part_%d" % i])
+      i += 1
+    return var
+  return None

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/coordinator.py

@@ -0,0 +1,507 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Coordinator to help multiple threads stop when requested."""
+import contextlib
+import sys
+import threading
+import time
+
+from tensorflow.python.framework import errors
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util import compat
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("train.Coordinator")
+class Coordinator:
+  """A coordinator for threads.
+
+  This class implements a simple mechanism to coordinate the termination of a
+  set of threads.
+
+  #### Usage:
+
+  ```python
+  # Create a coordinator.
+  coord = Coordinator()
+  # Start a number of threads, passing the coordinator to each of them.
+  ...start thread 1...(coord, ...)
+  ...start thread N...(coord, ...)
+  # Wait for all the threads to terminate.
+  coord.join(threads)
+  ```
+
+  Any of the threads can call `coord.request_stop()` to ask for all the threads
+  to stop.  To cooperate with the requests, each thread must check for
+  `coord.should_stop()` on a regular basis.  `coord.should_stop()` returns
+  `True` as soon as `coord.request_stop()` has been called.
+
+  A typical thread running with a coordinator will do something like:
+
+  ```python
+  while not coord.should_stop():
+    ...do some work...
+  ```
+
+  #### Exception handling:
+
+  A thread can report an exception to the coordinator as part of the
+  `request_stop()` call.  The exception will be re-raised from the
+  `coord.join()` call.
+
+  Thread code:
+
+  ```python
+  try:
+    while not coord.should_stop():
+      ...do some work...
+  except Exception as e:
+    coord.request_stop(e)
+  ```
+
+  Main code:
+
+  ```python
+  try:
+    ...
+    coord = Coordinator()
+    # Start a number of threads, passing the coordinator to each of them.
+    ...start thread 1...(coord, ...)
+    ...start thread N...(coord, ...)
+    # Wait for all the threads to terminate.
+    coord.join(threads)
+  except Exception as e:
+    ...exception that was passed to coord.request_stop()
+  ```
+
+  To simplify the thread implementation, the Coordinator provides a
+  context handler `stop_on_exception()` that automatically requests a stop if
+  an exception is raised.  Using the context handler the thread code above
+  can be written as:
+
+  ```python
+  with coord.stop_on_exception():
+    while not coord.should_stop():
+      ...do some work...
+  ```
+
+  #### Grace period for stopping:
+
+  After a thread has called `coord.request_stop()` the other threads have a
+  fixed time to stop, this is called the 'stop grace period' and defaults to 2
+  minutes.  If any of the threads is still alive after the grace period expires
+  `coord.join()` raises a RuntimeError reporting the laggards.
+
+  ```python
+  try:
+    ...
+    coord = Coordinator()
+    # Start a number of threads, passing the coordinator to each of them.
+    ...start thread 1...(coord, ...)
+    ...start thread N...(coord, ...)
+    # Wait for all the threads to terminate, give them 10s grace period
+    coord.join(threads, stop_grace_period_secs=10)
+  except RuntimeError:
+    ...one of the threads took more than 10s to stop after request_stop()
+    ...was called.
+  except Exception:
+    ...exception that was passed to coord.request_stop()
+  ```
+  """
+
+  def __init__(self, clean_stop_exception_types=None):
+    """Create a new Coordinator.
+
+    Args:
+      clean_stop_exception_types: Optional tuple of Exception types that should
+        cause a clean stop of the coordinator. If an exception of one of these
+        types is reported to `request_stop(ex)` the coordinator will behave as
+        if `request_stop(None)` was called.  Defaults to
+        `(tf.errors.OutOfRangeError,)` which is used by input queues to signal
+        the end of input. When feeding training data from a Python iterator it
+        is common to add `StopIteration` to this list.
+    """
+    if clean_stop_exception_types is None:
+      clean_stop_exception_types = (errors.OutOfRangeError,)
+    self._clean_stop_exception_types = tuple(clean_stop_exception_types)
+    # Protects all attributes.
+    self._lock = threading.Lock()
+    # Event set when threads must stop.
+    self._stop_event = threading.Event()
+    # Python exc_info to report.
+    # If not None, it should hold the returned value of sys.exc_info(), which is
+    # a tuple containing exception (type, value, traceback).
+    self._exc_info_to_raise = None
+    # True if we have called join() already.
+    self._joined = False
+    # Set of threads registered for joining when join() is called.  These
+    # threads will be joined in addition to the threads passed to the join()
+    # call.  It's ok if threads are both registered and passed to the join()
+    # call.
+    self._registered_threads = set()
+
+  def _filter_exception(self, ex):
+    """Check if the exception indicated in 'ex' should be ignored.
+
+    This method examines `ex` to check if it is an exception that should be
+    reported to the users.  If yes, it returns `ex` as is, otherwise it returns
+    None.
+
+    The code returns None for exception types listed in
+    `_clean_stop_exception_types`.
+
+    Args:
+      ex: None, an `Exception`, or a Python `exc_info` tuple as returned by
+        `sys.exc_info()`.
+
+    Returns:
+      ex or None.
+    """
+    if isinstance(ex, tuple):
+      ex2 = ex[1]
+    else:
+      ex2 = ex
+    if isinstance(ex2, self._clean_stop_exception_types):
+      # Ignore the exception.
+      ex = None
+    return ex
+
+  def request_stop(self, ex=None):
+    """Request that the threads stop.
+
+    After this is called, calls to `should_stop()` will return `True`.
+
+    Note: If an exception is being passed in, in must be in the context of
+    handling the exception (i.e. `try: ... except Exception as ex: ...`) and not
+    a newly created one.
+
+    Args:
+      ex: Optional `Exception`, or Python `exc_info` tuple as returned by
+        `sys.exc_info()`.  If this is the first call to `request_stop()` the
+        corresponding exception is recorded and re-raised from `join()`.
+    """
+    with self._lock:
+      ex = self._filter_exception(ex)
+      # If we have already joined the coordinator the exception will not have a
+      # chance to be reported, so just raise it normally.  This can happen if
+      # you continue to use a session have having stopped and joined the
+      # coordinator threads.
+      if self._joined:
+        if isinstance(ex, tuple):
+          _, ex_instance, _ = ex
+          raise ex_instance
+        elif ex is not None:
+          # NOTE(touts): This is bogus if request_stop() is not called
+          # from the exception handler that raised ex.
+          _, ex_instance, _ = sys.exc_info()
+          raise ex_instance
+      if not self._stop_event.is_set():
+        if ex and self._exc_info_to_raise is None:
+          if isinstance(ex, tuple):
+            logging.info("Error reported to Coordinator: %s",
+                         compat.as_str_any(ex[1]),
+                         exc_info=ex)
+            self._exc_info_to_raise = ex
+          else:
+            logging.info("Error reported to Coordinator: %s, %s",
+                         type(ex),
+                         compat.as_str_any(ex))
+            self._exc_info_to_raise = sys.exc_info()
+          # self._exc_info_to_raise should contain a tuple containing exception
+          # (type, value, traceback)
+          if (len(self._exc_info_to_raise) != 3 or
+              not self._exc_info_to_raise[0] or
+              not self._exc_info_to_raise[1]):
+            # Raise, catch and record the exception here so that error happens
+            # where expected.
+            try:
+              raise ValueError(
+                  "ex must be a tuple or sys.exc_info must return the current "
+                  "exception: %s"
+                  % self._exc_info_to_raise)
+            except ValueError:
+              # Record this error so it kills the coordinator properly.
+              # NOTE(touts): As above, this is bogus if request_stop() is not
+              # called from the exception handler that raised ex.
+              self._exc_info_to_raise = sys.exc_info()
+
+        self._stop_event.set()
+
+  def clear_stop(self):
+    """Clears the stop flag.
+
+    After this is called, calls to `should_stop()` will return `False`.
+    """
+    with self._lock:
+      self._joined = False
+      self._exc_info_to_raise = None
+      if self._stop_event.is_set():
+        self._stop_event.clear()
+
+  def should_stop(self):
+    """Check if stop was requested.
+
+    Returns:
+      True if a stop was requested.
+    """
+    return self._stop_event.is_set()
+
+  @contextlib.contextmanager
+  def stop_on_exception(self):
+    """Context manager to request stop when an Exception is raised.
+
+    Code that uses a coordinator must catch exceptions and pass
+    them to the `request_stop()` method to stop the other threads
+    managed by the coordinator.
+
+    This context handler simplifies the exception handling.
+    Use it as follows:
+
+    ```python
+    with coord.stop_on_exception():
+      # Any exception raised in the body of the with
+      # clause is reported to the coordinator before terminating
+      # the execution of the body.
+      ...body...
+    ```
+
+    This is completely equivalent to the slightly longer code:
+
+    ```python
+    try:
+      ...body...
+    except:
+      coord.request_stop(sys.exc_info())
+    ```
+
+    Yields:
+      nothing.
+    """
+    try:
+      yield
+    except:  # pylint: disable=bare-except
+      self.request_stop(ex=sys.exc_info())
+
+  def wait_for_stop(self, timeout=None):
+    """Wait till the Coordinator is told to stop.
+
+    Args:
+      timeout: Float.  Sleep for up to that many seconds waiting for
+        should_stop() to become True.
+
+    Returns:
+      True if the Coordinator is told stop, False if the timeout expired.
+    """
+    return self._stop_event.wait(timeout)
+
+  def register_thread(self, thread):
+    """Register a thread to join.
+
+    Args:
+      thread: A Python thread to join.
+    """
+    with self._lock:
+      self._registered_threads.add(thread)
+
+  def join(self, threads=None, stop_grace_period_secs=120,
+           ignore_live_threads=False):
+    """Wait for threads to terminate.
+
+    This call blocks until a set of threads have terminated.  The set of thread
+    is the union of the threads passed in the `threads` argument and the list
+    of threads that registered with the coordinator by calling
+    `Coordinator.register_thread()`.
+
+    After the threads stop, if an `exc_info` was passed to `request_stop`, that
+    exception is re-raised.
+
+    Grace period handling: When `request_stop()` is called, threads are given
+    'stop_grace_period_secs' seconds to terminate.  If any of them is still
+    alive after that period expires, a `RuntimeError` is raised.  Note that if
+    an `exc_info` was passed to `request_stop()` then it is raised instead of
+    that `RuntimeError`.
+
+    Args:
+      threads: List of `threading.Threads`. The started threads to join in
+        addition to the registered threads.
+      stop_grace_period_secs: Number of seconds given to threads to stop after
+        `request_stop()` has been called.
+      ignore_live_threads: If `False`, raises an error if any of the threads are
+        still alive after `stop_grace_period_secs`.
+
+    Raises:
+      RuntimeError: If any thread is still alive after `request_stop()`
+        is called and the grace period expires.
+    """
+    # Threads registered after this call will not be joined.
+    with self._lock:
+      if threads is None:
+        threads = self._registered_threads
+      else:
+        threads = self._registered_threads.union(set(threads))
+      # Copy the set into a list to avoid race conditions where a new thread
+      # is added while we are waiting.
+      threads = list(threads)
+
+    # Wait for all threads to stop or for request_stop() to be called.
+    while any(t.is_alive() for t in threads) and not self.wait_for_stop(1.0):
+      pass
+
+    # If any thread is still alive, wait for the grace period to expire.
+    # By the time this check is executed, threads may still be shutting down,
+    # so we add a sleep of increasing duration to give them a chance to shut
+    # down without losing too many cycles.
+    # The sleep duration is limited to the remaining grace duration.
+    stop_wait_secs = 0.001
+    while any(t.is_alive() for t in threads) and stop_grace_period_secs >= 0.0:
+      time.sleep(stop_wait_secs)
+      stop_grace_period_secs -= stop_wait_secs
+      stop_wait_secs = 2 * stop_wait_secs
+      # Keep the waiting period within sane bounds.
+      # The minimum value is to avoid decreasing stop_wait_secs to a value
+      # that could cause stop_grace_period_secs to remain unchanged.
+      stop_wait_secs = max(min(stop_wait_secs, stop_grace_period_secs), 0.001)
+
+    # List the threads still alive after the grace period.
+    stragglers = [t.name for t in threads if t.is_alive()]
+
+    # Terminate with an exception if appropriate.
+    with self._lock:
+      self._joined = True
+      self._registered_threads = set()
+      if self._exc_info_to_raise:
+        _, ex_instance, _ = self._exc_info_to_raise
+        raise ex_instance
+      elif stragglers:
+        if ignore_live_threads:
+          logging.info("Coordinator stopped with threads still running: %s",
+                       " ".join(stragglers))
+        else:
+          raise RuntimeError(
+              "Coordinator stopped with threads still running: %s" %
+              " ".join(stragglers))
+
+  @property
+  def joined(self):
+    return self._joined
+
+  def raise_requested_exception(self):
+    """If an exception has been passed to `request_stop`, this raises it."""
+    with self._lock:
+      if self._exc_info_to_raise:
+        _, ex_instance, _ = self._exc_info_to_raise
+        raise ex_instance
+
+
+# Threads for the standard services.
+@tf_export(v1=["train.LooperThread"])
+class LooperThread(threading.Thread):
+  """A thread that runs code repeatedly, optionally on a timer.
+
+  This thread class is intended to be used with a `Coordinator`.  It repeatedly
+  runs code specified either as `target` and `args` or by the `run_loop()`
+  method.
+
+  Before each run the thread checks if the coordinator has requested stop.  In
+  that case the looper thread terminates immediately.
+
+  If the code being run raises an exception, that exception is reported to the
+  coordinator and the thread terminates.  The coordinator will then request all
+  the other threads it coordinates to stop.
+
+  You typically pass looper threads to the supervisor `Join()` method.
+  """
+
+  def __init__(self, coord, timer_interval_secs, target=None, args=None,
+               kwargs=None):
+    """Create a LooperThread.
+
+    Args:
+      coord: A Coordinator.
+      timer_interval_secs: Time boundaries at which to call Run(), or None
+        if it should be called back to back.
+      target: Optional callable object that will be executed in the thread.
+      args: Optional arguments to pass to `target` when calling it.
+      kwargs: Optional keyword arguments to pass to `target` when calling it.
+
+    Raises:
+      ValueError: If one of the arguments is invalid.
+    """
+    if not isinstance(coord, Coordinator):
+      raise ValueError("'coord' argument must be a Coordinator: %s" % coord)
+    super(LooperThread, self).__init__()
+    self.daemon = True
+    self._coord = coord
+    self._timer_interval_secs = timer_interval_secs
+    self._target = target
+    if self._target:
+      self._args = args or ()
+      self._kwargs = kwargs or {}
+    elif args or kwargs:
+      raise ValueError("'args' and 'kwargs' argument require that you also "
+                       "pass 'target'")
+    self._coord.register_thread(self)
+
+  @staticmethod
+  def loop(coord, timer_interval_secs, target, args=None, kwargs=None):
+    """Start a LooperThread that calls a function periodically.
+
+    If `timer_interval_secs` is None the thread calls `target(args)`
+    repeatedly.  Otherwise `target(args)` is called every `timer_interval_secs`
+    seconds.  The thread terminates when a stop of the coordinator is
+    requested.
+
+    Args:
+      coord: A Coordinator.
+      timer_interval_secs: Number. Time boundaries at which to call `target`.
+      target: A callable object.
+      args: Optional arguments to pass to `target` when calling it.
+      kwargs: Optional keyword arguments to pass to `target` when calling it.
+
+    Returns:
+      The started thread.
+    """
+    looper = LooperThread(coord, timer_interval_secs, target=target, args=args,
+                          kwargs=kwargs)
+    looper.start()
+    return looper
+
+  def run(self):
+    with self._coord.stop_on_exception():
+      self.start_loop()
+      if self._timer_interval_secs is None:
+        # Call back-to-back.
+        while not self._coord.should_stop():
+          self.run_loop()
+      else:
+        # Next time at which to call run_loop(), starts as 'now'.
+        next_timer_time = time.time()
+        while not self._coord.wait_for_stop(next_timer_time - time.time()):
+          next_timer_time += self._timer_interval_secs
+          self.run_loop()
+      self.stop_loop()
+
+  def start_loop(self):
+    """Called when the thread starts."""
+    pass
+
+  def stop_loop(self):
+    """Called when the thread stops."""
+    pass
+
+  def run_loop(self):
+    """Called at 'timer_interval_secs' boundaries."""
+    if self._target:
+      self._target(*self._args, **self._kwargs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/device_setter.py

@@ -0,0 +1,225 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Device function for replicated training."""
+from tensorflow.core.framework import node_def_pb2
+from tensorflow.python.framework import device as pydev
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.training import server_lib
+from tensorflow.python.util.tf_export import tf_export
+
+# This is a tuple of PS ops used by tf.estimator.Estimator which should work in
+# almost all of cases.
+STANDARD_PS_OPS = ("Variable", "VariableV2", "AutoReloadVariable",
+                   "MutableHashTable", "MutableHashTableV2",
+                   "MutableHashTableOfTensors", "MutableHashTableOfTensorsV2",
+                   "MutableDenseHashTable", "MutableDenseHashTableV2",
+                   "VarHandleOp", "BoostedTreesEnsembleResourceHandleOp",
+                   "BoostedTreesQuantileStreamResourceHandleOp",
+                   "ResourceConditionalAccumulator",
+                   "DecisionTreeResource")
+
+
+class _RoundRobinStrategy:
+  """Returns the next ps task index for placement in round-robin order.
+
+  This class is not to be used directly by users.  See instead
+  `replica_device_setter()` below.
+  """
+
+  def __init__(self, num_tasks):
+    """Create a new `_RoundRobinStrategy`.
+
+    Args:
+      num_tasks: Number of ps tasks to cycle among.
+    """
+    self._num_tasks = num_tasks
+    self._next_task = 0
+
+  def __call__(self, unused_op):
+    """Choose a ps task index for the given `Operation`.
+
+    Args:
+      unused_op: An `Operation` to be placed on ps.
+
+    Returns:
+      The next ps task index to use for the `Operation`. Returns the next
+      index, in the range `[offset, offset + num_tasks)`.
+    """
+    task = self._next_task
+    self._next_task = (self._next_task + 1) % self._num_tasks
+    return task
+
+
+class _ReplicaDeviceChooser:
+  """Class to choose devices for Ops in a replicated training setup.
+
+  This class is not to be used directly by users.  See instead
+  `replica_device_setter()` below.
+  """
+
+  def __init__(self, ps_tasks, ps_device, worker_device, merge_devices, ps_ops,
+               ps_strategy):
+    """Create a new `_ReplicaDeviceChooser`.
+
+    Args:
+      ps_tasks: Number of tasks in the `ps` job.
+      ps_device: String.  Name of the `ps` job.
+      worker_device: String.  Name of the `worker` job.
+      merge_devices: Boolean. Set to True to allow merging of device specs.
+      ps_ops: List of strings representing `Operation` types that need to be
+        placed on `ps` devices.
+      ps_strategy: A callable invoked for every ps `Operation` (i.e. matched by
+        `ps_ops`), that takes the `Operation` and returns the ps task index to
+        use.
+    """
+    self._ps_tasks = ps_tasks
+    self._ps_device = ps_device
+    self._worker_device = worker_device
+    self._merge_devices = merge_devices
+    self._ps_ops = ps_ops
+    self._ps_strategy = ps_strategy
+
+  def device_function(self, op):
+    """Choose a device for `op`.
+
+    Args:
+      op: an `Operation`.
+
+    Returns:
+      The device to use for the `Operation`.
+    """
+    # If we don't return early here, either merge_devices is True, or op.device
+    # is empty (in which case merging is a no-op). So we can always merge below.
+    if not self._merge_devices and op.device:
+      return op.device
+
+    current_device = pydev.DeviceSpec.from_string(op.device or "")
+
+    # The ps_device will be used for specified ops (ps_ops) whenever it is
+    # present and ps_tasks is non-zero. However, its task number will only be
+    # set (using ps_strategy) if there is a job field in ps_device that won't be
+    # changed by the job field (if present) in current_device.
+    node_def = op if isinstance(op, node_def_pb2.NodeDef) else op.node_def
+    if self._ps_tasks and self._ps_device and node_def.op in self._ps_ops:
+      ps_device = pydev.DeviceSpec.from_string(self._ps_device)
+
+      current_job, ps_job = current_device.job, ps_device.job
+      if ps_job and (not current_job or current_job == ps_job):
+        ps_device = ps_device.replace(task=self._ps_strategy(op))
+
+      ps_device = ps_device.make_merged_spec(current_device)
+      return ps_device.to_string()
+
+    worker_device = pydev.DeviceSpec.from_string(self._worker_device or "")
+    worker_device = worker_device.make_merged_spec(current_device)
+    return worker_device.to_string()
+
+
+@tf_export(v1=["train.replica_device_setter"])
+def replica_device_setter(ps_tasks=0,
+                          ps_device="/job:ps",
+                          worker_device="/job:worker",
+                          merge_devices=True,
+                          cluster=None,
+                          ps_ops=None,
+                          ps_strategy=None):
+  """Return a `device function` to use when building a Graph for replicas.
+
+  Device Functions are used in `with tf.device(device_function):` statement to
+  automatically assign devices to `Operation` objects as they are constructed,
+  Device constraints are added from the inner-most context first, working
+  outwards. The merging behavior adds constraints to fields that are yet unset
+  by a more inner context. Currently the fields are (job, task, cpu/gpu).
+
+  If `cluster` is `None`, and `ps_tasks` is 0, the returned function is a no-op.
+  Otherwise, the value of `ps_tasks` is derived from `cluster`.
+
+  By default, only Variable ops are placed on ps tasks, and the placement
+  strategy is round-robin over all ps tasks. A custom `ps_strategy` may be used
+  to do more intelligent placement, such as
+  `tf.contrib.training.GreedyLoadBalancingStrategy`.
+
+  For example,
+
+  ```python
+  # To build a cluster with two ps jobs on hosts ps0 and ps1, and 3 worker
+  # jobs on hosts worker0, worker1 and worker2.
+  cluster_spec = {
+      "ps": ["ps0:2222", "ps1:2222"],
+      "worker": ["worker0:2222", "worker1:2222", "worker2:2222"]}
+  with
+  tf.compat.v1.device(tf.compat.v1.train.replica_device_setter(cluster=cluster_spec)):
+    # Build your graph
+    v1 = tf.Variable(...)  # assigned to /job:ps/task:0
+    v2 = tf.Variable(...)  # assigned to /job:ps/task:1
+    v3 = tf.Variable(...)  # assigned to /job:ps/task:0
+  # Run compute
+  ```
+
+  Args:
+    ps_tasks: Number of tasks in the `ps` job.  Ignored if `cluster` is
+      provided.
+    ps_device: String.  Device of the `ps` job.  If empty no `ps` job is used.
+      Defaults to `ps`.
+    worker_device: String.  Device of the `worker` job.  If empty no `worker`
+      job is used.
+    merge_devices: `Boolean`. If `True`, merges or only sets a device if the
+      device constraint is completely unset. merges device specification rather
+      than overriding them.
+    cluster: `ClusterDef` proto or `ClusterSpec`.
+    ps_ops: List of strings representing `Operation` types that need to be
+      placed on `ps` devices.  If `None`, defaults to `STANDARD_PS_OPS`.
+    ps_strategy: A callable invoked for every ps `Operation` (i.e. matched by
+      `ps_ops`), that takes the `Operation` and returns the ps task index to
+      use.  If `None`, defaults to a round-robin strategy across all `ps`
+      devices.
+
+  Returns:
+    A function to pass to `tf.device()`.
+
+  Raises:
+    TypeError if `cluster` is not a dictionary or `ClusterDef` protocol buffer,
+    or if `ps_strategy` is provided but not a callable.
+  """
+  if cluster is not None:
+    if isinstance(cluster, server_lib.ClusterSpec):
+      cluster_spec = cluster.as_dict()
+    else:
+      cluster_spec = server_lib.ClusterSpec(cluster).as_dict()
+    # Get ps_job_name from ps_device by stripping "/job:".
+    ps_job_name = pydev.DeviceSpec.from_string(ps_device).job
+    if ps_job_name not in cluster_spec or cluster_spec[ps_job_name] is None:
+      return None
+    ps_tasks = len(cluster_spec[ps_job_name])
+
+  if ps_tasks == 0:
+    return None
+
+  if ps_ops is None:
+    # TODO(sherrym): Variables in the LOCAL_VARIABLES collection should not be
+    # placed in the parameter server.
+    ps_ops = list(STANDARD_PS_OPS)
+
+  if not merge_devices:
+    logging.warning(
+        "DEPRECATION: It is recommended to set merge_devices=true in "
+        "replica_device_setter")
+  if ps_strategy is None:
+    ps_strategy = _RoundRobinStrategy(ps_tasks)
+  if not callable(ps_strategy):
+    raise TypeError("ps_strategy must be callable")
+  chooser = _ReplicaDeviceChooser(ps_tasks, ps_device, worker_device,
+                                  merge_devices, ps_ops, ps_strategy)
+  return chooser.device_function

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/evaluation.py

@@ -0,0 +1,273 @@
+# 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.
+# ==============================================================================
+"""Contains functions for evaluation and summarization of metrics."""
+
+import math
+import time
+
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import init_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import state_ops
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.training import basic_session_run_hooks
+from tensorflow.python.training import monitored_session
+from tensorflow.python.training import session_run_hook
+
+
+def _get_or_create_eval_step():
+  """Gets or creates the eval step `Tensor`.
+
+  Returns:
+    A `Tensor` representing a counter for the evaluation step.
+
+  Raises:
+    ValueError: If multiple `Tensors` have been added to the
+      `tf.GraphKeys.EVAL_STEP` collection.
+  """
+  graph = ops.get_default_graph()
+  eval_steps = graph.get_collection(ops.GraphKeys.EVAL_STEP)
+  if len(eval_steps) == 1:
+    return eval_steps[0]
+  elif len(eval_steps) > 1:
+    raise ValueError('Multiple tensors added to tf.GraphKeys.EVAL_STEP')
+  else:
+    counter = variable_scope.get_variable(
+        'eval_step',
+        shape=[],
+        dtype=dtypes.int64,
+        initializer=init_ops.zeros_initializer(),
+        trainable=False,
+        collections=[ops.GraphKeys.LOCAL_VARIABLES, ops.GraphKeys.EVAL_STEP])
+    return counter
+
+
+def _get_latest_eval_step_value(update_ops):
+  """Gets the eval step `Tensor` value after running `update_ops`.
+
+  Args:
+    update_ops: A list of `Tensors` or a dictionary of names to `Tensors`, which
+      are run before reading the eval step value.
+
+  Returns:
+    A `Tensor` representing the value for the evaluation step.
+  """
+  if isinstance(update_ops, dict):
+    update_ops = list(update_ops.values())
+
+  with ops.control_dependencies(update_ops):
+    return array_ops.identity(_get_or_create_eval_step().read_value())
+
+
+class _MultiStepStopAfterNEvalsHook(session_run_hook.SessionRunHook):
+  """Run hook used by the evaluation routines to run the `eval_ops` N times."""
+
+  def __init__(self, num_evals, steps_per_run=1):
+    """Constructs the run hook.
+
+    Args:
+      num_evals: The number of evaluations to run for. if set to None, will
+        iterate the dataset until all inputs are exhausted.
+      steps_per_run: Number of steps executed per run call.
+    """
+    self._num_evals = num_evals
+    self._evals_completed = None
+    self._steps_per_run_initial_value = steps_per_run
+
+  def _set_evals_completed_tensor(self, updated_eval_step):
+    self._evals_completed = updated_eval_step
+
+  def begin(self):
+    self._steps_per_run_variable = \
+        basic_session_run_hooks.get_or_create_steps_per_run_variable()
+
+  def after_create_session(self, session, coord):
+    # Update number of steps to run in the first run call
+    if self._num_evals is None:
+      steps = self._steps_per_run_initial_value
+    else:
+      steps = min(self._steps_per_run_initial_value, self._num_evals)
+    self._steps_per_run_variable.load(steps, session=session)
+
+  def before_run(self, run_context):
+    return session_run_hook.SessionRunArgs(
+        {'evals_completed': self._evals_completed})
+
+  def after_run(self, run_context, run_values):
+    evals_completed = run_values.results['evals_completed']
+    # Update number of steps to run in the next iteration
+    if self._num_evals is None:
+      steps = self._steps_per_run_initial_value
+    else:
+      steps = min(self._num_evals - evals_completed,
+                  self._steps_per_run_initial_value)
+    self._steps_per_run_variable.load(steps, session=run_context.session)
+
+    if self._num_evals is None:
+      logging.info('Evaluation [%d]', evals_completed)
+    else:
+      logging.info('Evaluation [%d/%d]', evals_completed, self._num_evals)
+    if self._num_evals is not None and evals_completed >= self._num_evals:
+      run_context.request_stop()
+
+
+class _StopAfterNEvalsHook(session_run_hook.SessionRunHook):
+  """Run hook used by the evaluation routines to run the `eval_ops` N times."""
+
+  def __init__(self, num_evals, log_progress=True):
+    """Constructs the run hook.
+
+    Args:
+      num_evals: The number of evaluations to run for. if set to None, will
+        iterate the dataset until all inputs are exhausted.
+      log_progress: Whether to log evaluation progress, defaults to True.
+    """
+    # The number of evals to run for.
+    self._num_evals = num_evals
+    self._evals_completed = None
+    self._log_progress = log_progress
+    # Reduce logging frequency if there are 20 or more evaluations.
+    self._log_frequency = (1 if (num_evals is None or num_evals < 20) else
+                           math.floor(num_evals / 10.))
+
+  def _set_evals_completed_tensor(self, updated_eval_step):
+    self._evals_completed = updated_eval_step
+
+  def before_run(self, run_context):
+    return session_run_hook.SessionRunArgs(
+        {'evals_completed': self._evals_completed})
+
+  def after_run(self, run_context, run_values):
+    evals_completed = run_values.results['evals_completed']
+    if self._log_progress:
+      if self._num_evals is None:
+        logging.info('Evaluation [%d]', evals_completed)
+      else:
+        if ((evals_completed % self._log_frequency) == 0 or
+            (self._num_evals == evals_completed)):
+          logging.info('Evaluation [%d/%d]', evals_completed, self._num_evals)
+    if self._num_evals is not None and evals_completed >= self._num_evals:
+      run_context.request_stop()
+
+
+def _evaluate_once(checkpoint_path,
+                   master='',
+                   scaffold=None,
+                   eval_ops=None,
+                   feed_dict=None,
+                   final_ops=None,
+                   final_ops_feed_dict=None,
+                   hooks=None,
+                   config=None):
+  """Evaluates the model at the given checkpoint path.
+
+  During a single evaluation, the `eval_ops` is run until the session is
+  interrupted or requested to finish. This is typically requested via a
+  `tf.contrib.training.StopAfterNEvalsHook` which results in `eval_ops` running
+  the requested number of times.
+
+  Optionally, a user can pass in `final_ops`, a single `Tensor`, a list of
+  `Tensors` or a dictionary from names to `Tensors`. The `final_ops` is
+  evaluated a single time after `eval_ops` has finished running and the fetched
+  values of `final_ops` are returned. If `final_ops` is left as `None`, then
+  `None` is returned.
+
+  One may also consider using a `tf.contrib.training.SummaryAtEndHook` to record
+  summaries after the `eval_ops` have run. If `eval_ops` is `None`, the
+  summaries run immediately after the model checkpoint has been restored.
+
+  Note that `evaluate_once` creates a local variable used to track the number of
+  evaluations run via `tf.contrib.training.get_or_create_eval_step`.
+  Consequently, if a custom local init op is provided via a `scaffold`, the
+  caller should ensure that the local init op also initializes the eval step.
+
+  Args:
+    checkpoint_path: The path to a checkpoint to use for evaluation.
+    master: The BNS address of the TensorFlow master.
+    scaffold: An tf.compat.v1.train.Scaffold instance for initializing variables
+      and restoring variables. Note that `scaffold.init_fn` is used by the
+      function to restore the checkpoint. If you supply a custom init_fn, then
+      it must also take care of restoring the model from its checkpoint.
+    eval_ops: A single `Tensor`, a list of `Tensors` or a dictionary of names to
+      `Tensors`, which is run until the session is requested to stop, commonly
+      done by a `tf.contrib.training.StopAfterNEvalsHook`.
+    feed_dict: The feed dictionary to use when executing the `eval_ops`.
+    final_ops: A single `Tensor`, a list of `Tensors` or a dictionary of names
+      to `Tensors`.
+    final_ops_feed_dict: A feed dictionary to use when evaluating `final_ops`.
+    hooks: List of `tf.estimator.SessionRunHook` callbacks which are run inside
+      the evaluation loop.
+    config: An instance of `tf.compat.v1.ConfigProto` that will be used to
+      configure the `Session`. If left as `None`, the default will be used.
+
+  Returns:
+    The fetched values of `final_ops` or `None` if `final_ops` is `None`.
+  """
+  eval_step = _get_or_create_eval_step()
+
+  # Prepare the run hooks.
+  hooks = list(hooks or [])
+
+  if eval_ops is not None:
+    if any(isinstance(h, _MultiStepStopAfterNEvalsHook) for h in hooks):
+      steps_per_run_variable = \
+          basic_session_run_hooks.get_or_create_steps_per_run_variable()
+      update_eval_step = state_ops.assign_add(
+          eval_step,
+          math_ops.cast(steps_per_run_variable, dtype=eval_step.dtype),
+          use_locking=True)
+    else:
+      update_eval_step = state_ops.assign_add(eval_step, 1, use_locking=True)
+
+    if isinstance(eval_ops, dict):
+      eval_ops['update_eval_step'] = update_eval_step
+    elif isinstance(eval_ops, (tuple, list)):
+      eval_ops = list(eval_ops) + [update_eval_step]
+    else:
+      eval_ops = [eval_ops, update_eval_step]
+
+    eval_step_value = _get_latest_eval_step_value(eval_ops)
+
+    for h in hooks:
+      if isinstance(h, (_StopAfterNEvalsHook, _MultiStepStopAfterNEvalsHook)):
+        h._set_evals_completed_tensor(eval_step_value)  # pylint: disable=protected-access
+
+  logging.info('Starting evaluation at ' +
+               time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime()))
+  start = time.time()
+  # Prepare the session creator.
+  session_creator = monitored_session.ChiefSessionCreator(
+      scaffold=scaffold,
+      checkpoint_filename_with_path=checkpoint_path,
+      master=master,
+      config=config)
+
+  final_ops_hook = basic_session_run_hooks.FinalOpsHook(final_ops,
+                                                        final_ops_feed_dict)
+  hooks.append(final_ops_hook)
+
+  with monitored_session.MonitoredSession(
+      session_creator=session_creator, hooks=hooks) as session:
+    if eval_ops is not None:
+      while not session.should_stop():
+        session.run(eval_ops, feed_dict)
+  logging.info('Inference Time : {:0.5f}s'.format(time.time() - start))
+
+  logging.info('Finished evaluation at ' +
+               time.strftime('%Y-%m-%d-%H:%M:%S', time.localtime()))
+  return final_ops_hook.final_ops_values

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/experimental/loss_scale.py

@@ -0,0 +1,453 @@
+# 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.
+# ==============================================================================
+"""Contains LossScale classes."""
+import abc
+
+from tensorflow.python.distribute import distribute_lib
+from tensorflow.python.distribute import reduce_util
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import indexed_slices
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import cond
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import variable_v1
+from tensorflow.python.ops import variables
+from tensorflow.python.trackable import base as trackable
+from tensorflow.python.util import deprecation
+from tensorflow.python.util import nest
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated_endpoints('mixed_precision.experimental.LossScale',
+                                  'train.experimental.LossScale')
+@tf_export(
+    v1=[
+        'mixed_precision.LossScale',
+        'mixed_precision.experimental.LossScale',
+        'train.experimental.LossScale'
+    ])
+class LossScale(trackable.Trackable, metaclass=abc.ABCMeta):
+  """Base class for all TF1 loss scales.
+
+  This is an abstract base class, so you cannot instantiate it directly.
+  Instead, use one of its concrete subclasses:
+    * `tf.compat.v1.mixed_precision.DynamicLossScale`
+    * `tf.compat.v1.mixed_precision.FixedLossScale`
+
+  Loss scaling is a process that multiplies the loss by a multiplier called the
+  loss scale, and divides each gradient by the same multiplier. The pseudocode
+  for this process is:
+
+  ```
+  loss = ...
+  loss *= loss_scale
+  grads = gradients(loss, vars)
+  grads /= loss_scale
+  ```
+
+  Mathematically, loss scaling has no effect, but can help avoid numerical
+  underflow in intermediate gradients when float16 tensors are used for mixed
+  precision training. By multiplying the loss, each intermediate gradient will
+  have the same multiplier applied.
+
+  Instances of this class represent a loss scale. Calling instances of this
+  class returns the loss scale as a scalar float32 tensor, while method
+  `update()` updates the loss scale depending on the values of the gradients.
+  Optimizers use instances of this class to scale loss and gradients.
+
+  In most functions that accept a LossScale, you can also pass an int (such as
+  8) to create a `FixedLossScale` or the string `"dynamic"` to create a dynamic
+  loss scale.
+  """
+
+  def __init__(self):
+    """Initializes the loss scale class."""
+    self._weights = {}
+
+  @abc.abstractmethod
+  def __call__(self):
+    """Returns the current loss scale as a scalar `float32` tensor."""
+    pass
+
+  @abc.abstractmethod
+  def update(self, grads):
+    """Updates the value of the loss scale.
+
+    The loss scale will be potentially updated, based on the value of `grads`.
+    The tensor returned by calling this class is only updated when this function
+    is evaluated.
+
+    In eager mode, this directly updates the loss scale, so that calling
+    `__call__` will return the newly updated loss scale. In graph mode,
+    this returns an op that, when evaluated, updates the loss scale.
+
+    This function also returns a `should_apply_gradients` bool. If False,
+    gradients should not be applied to the variables that step, as nonfinite
+    gradients were found, and the loss scale has been be updated to reduce the
+    chance of finding nonfinite gradients in the next step. Some loss scale
+    classes will always return True, as they cannot adjust themselves in
+    response to nonfinite gradients.
+
+    When a DistributionStrategy is used, this function may only be called in a
+    cross-replica context.
+
+    Args:
+      grads: A nested structure of unscaled gradients, each which is the
+        gradient of the loss with respect to a weight. The gradients should have
+        already been divided by the loss scale being before passed to this
+        function. 'None' gradients are accepted, and are ignored.
+
+    Returns:
+      update_op: In eager mode, None. In graph mode, an op to update the loss
+        scale.
+      should_apply_gradients: Either a bool or a scalar boolean tensor. If
+        False, the caller should skip applying `grads` to the variables this
+        step.
+    """
+    pass
+
+  def _add_weight(self, name, initial_value, dtype=None):
+    """Adds a weight to this loss scale.
+
+    Args:
+      name: Variable name.
+      initial_value: The variable's initial value.
+      dtype: The type of the variable.
+
+    Returns:
+      A variable.
+
+    Raises:
+      RuntimeError: If a weight with `name` has already been added.
+    """
+    variable = variable_v1.VariableV1(
+        initial_value=initial_value,
+        name=name,
+        dtype=dtype,
+        trainable=False,
+        use_resource=True,
+        synchronization=variables.VariableSynchronization.AUTO,
+        # Set aggregation to NONE, as loss scaling variables should never be
+        # aggregated.
+        aggregation=variables.VariableAggregation.NONE)
+    if context.executing_eagerly():
+      graph_key = None
+    else:
+      graph = ops.get_default_graph()
+      graph_key = graph._graph_key  # pylint: disable=protected-access
+
+    key = (name, graph_key)
+    if self._weights.get(key, None) is not None:
+      raise RuntimeError('Duplicate variables detected. {}'.format(key))
+    self._weights[key] = variable
+    self._handle_deferred_dependencies(name=name, trackable=variable)
+    return variable
+
+  def _trackable_children(self,
+                          save_type=trackable.SaveType.CHECKPOINT,
+                          **kwargs):
+    """From Trackable. Gather graph-specific weights to save."""
+    if context.executing_eagerly():
+      graph_key = None
+    else:
+      graph = ops.get_default_graph()
+      graph_key = graph._graph_key  # pylint: disable=protected-access
+    weights = {}
+    for (name, g), v in sorted(self._weights.items(), key=lambda i: i[0][0]):
+      if g == graph_key:
+        weights[name] = v
+    weights.update(
+        super(LossScale, self)._trackable_children(save_type, **kwargs))
+    return weights
+
+  def _lookup_dependency(self, name, cached_dependencies=None):
+    """From Trackable. Find a weight in the current graph."""
+    unconditional = super(LossScale, self)._lookup_dependency(
+        name, cached_dependencies)
+    if unconditional is not None:
+      return unconditional
+    if context.executing_eagerly():
+      graph_key = None
+    else:
+      graph = ops.get_default_graph()
+      graph_key = graph._graph_key  # pylint: disable=protected-access
+    return self._weights.get((name, graph_key), None)
+
+  @abc.abstractmethod
+  def get_config(self):
+    """Returns the config of this loss scale."""
+    pass
+
+  @classmethod
+  def from_config(cls, config):
+    """Creates the LossScale from its config."""
+    return cls(**config)
+
+
+@deprecation.deprecated_endpoints('mixed_precision.experimental.FixedLossScale',
+                                  'train.experimental.FixedLossScale')
+@tf_export(
+    v1=[
+        'mixed_precision.FixedLossScale',
+        'mixed_precision.experimental.FixedLossScale',
+        'train.experimental.FixedLossScale'
+    ])
+class FixedLossScale(LossScale):
+  """Loss scale with a fixed value.
+
+  The loss scale is not updated for the lifetime of instances of this class.
+  A given instance of this class always returns the same number when called.
+  """
+
+  @deprecation.deprecated(
+      None, 'Use tf.keras.mixed_precision.LossScaleOptimizer instead. '
+            'LossScaleOptimizer now has all the functionality of '
+            'FixedLossScale')
+  def __init__(self, loss_scale_value):
+    """Creates the fixed loss scale.
+
+    Args:
+      loss_scale_value: A Python float. Its ideal value varies depending on
+        models to run. Choosing a too small loss_scale might affect model
+        quality; a too big loss_scale might cause inf or nan. There is no single
+        right loss_scale to apply. There is no harm choosing a relatively big
+        number as long as no nan or inf is encountered in training.
+
+    Raises:
+      ValueError: If loss_scale_value is less than 1.
+    """
+    super(FixedLossScale, self).__init__()
+    if not isinstance(loss_scale_value, (int, float)):
+      raise ValueError('loss_scale_value must be a Python int or float.')
+    if loss_scale_value < 1:
+      raise ValueError('loss_scale_value must be at least 1.')
+    # It's important we do not create tensors in the constructor, as such
+    # tensors might be on a different device or tf.function vs when the tensor
+    # is used. This would hurt performance. Therefore, we do not create a tensor
+    # from loss_scale_value, but instead leave it as a Python float.
+    # TODO(reedwm): Also do not create tensors in the DynamicLossScale
+    # constructor.
+    self._loss_scale_value = float(loss_scale_value)
+
+  def __call__(self):
+    return ops.convert_to_tensor(self._loss_scale_value)
+
+  def update(self, grads):
+    del grads
+    return control_flow_ops.no_op(), True
+
+  def __repr__(self):
+    return 'FixedLossScale(%s)' % self._loss_scale_value
+
+  def get_config(self):
+    return {'loss_scale_value': self._loss_scale_value}
+
+
+def _is_all_finite(grads):
+  """Returns a scalar boolean tensor indicating if all gradients are finite."""
+  def raw_values(g):
+    return g.values if isinstance(g, indexed_slices.IndexedSlices) else g
+
+  is_finite_per_grad = [
+      math_ops.reduce_all(math_ops.is_finite(raw_values(g)))
+      for g in grads
+      if g is not None
+  ]
+  return math_ops.reduce_all(is_finite_per_grad)
+
+
+def _op_in_graph_mode(tensor):
+  """Returns the tensor's op in graph mode, or the tensor in eager mode.
+
+  This is useful because sometimes an op is needed in graph mode instead of a
+  tensor. In eager mode, there are no ops.
+
+  Args:
+    tensor: A tensor.
+
+  Returns:
+    The tensor's op in graph mode. The tensor in eager mode.
+  """
+  if context.executing_eagerly():
+    return tensor
+  return tensor.op
+
+
+def _assign_if_finite(var, value):
+  """Assigns a value to a variable if the value is finite."""
+  return cond.cond(
+      math_ops.is_finite(value), lambda: _op_in_graph_mode(var.assign(value)),
+      control_flow_ops.no_op)
+
+
+@deprecation.deprecated_endpoints(
+    'mixed_precision.experimental.DynamicLossScale',
+    'train.experimental.DynamicLossScale')
+@tf_export(
+    v1=[
+        'mixed_precision.DynamicLossScale',
+        'mixed_precision.experimental.DynamicLossScale',
+        'train.experimental.DynamicLossScale'
+    ])
+class DynamicLossScale(LossScale):
+  """Loss scale that dynamically adjusts itself.
+
+  Dynamic loss scaling works by adjusting the loss scale as training progresses.
+  The goal is to keep the loss scale as high as possible without overflowing the
+  gradients. As long as the gradients do not overflow, raising the loss scale
+  never hurts.
+
+  The algorithm starts by setting the loss scale to an initial value. Every N
+  steps that the gradients are finite, the loss scale is increased by some
+  factor. However, if a NaN or Inf gradient is found, the gradients for that
+  step are not applied, and the loss scale is decreased by the factor. This
+  process tends to keep the loss scale as high as possible without gradients
+  overflowing.
+  """
+
+  @deprecation.deprecated(
+      None, 'Use tf.keras.mixed_precision.LossScaleOptimizer instead. '
+            'LossScaleOptimizer now has all the functionality of '
+            'DynamicLossScale')
+  def __init__(self,
+               initial_loss_scale=2 ** 15,  # See docstring for why this is big.
+               increment_period=2000,
+               multiplier=2.):
+    """Creates the dynamic loss scale.
+
+    Args:
+      initial_loss_scale: A Python float.  The loss scale to use at the
+        beginning. It's better to start this at a very high number, because a
+        loss scale that is too high gets lowered far more quickly than a loss
+        scale that is too low gets raised. The default is 2 ** 15, which is
+        approximately half the maximum float16 value.
+      increment_period: Increases loss scale every `increment_period`
+        consecutive steps that finite gradients are encountered. If a nonfinite
+        gradient is encountered, the count is reset back to zero.
+      multiplier: The multiplier to use when increasing or decreasing the loss
+        scale.
+    """
+    super(DynamicLossScale, self).__init__()
+    self._initial_loss_scale = float(initial_loss_scale)
+    self._increment_period = int(increment_period)
+    self._multiplier = float(multiplier)
+
+    self._current_loss_scale = self._add_weight(
+        name='current_loss_scale',
+        dtype=dtypes.float32,
+        initial_value=self._initial_loss_scale)
+    # The number of consecutive steps with finite gradients since the last
+    # nonfinite gradient or change in loss scale.
+    self._num_good_steps = self._add_weight(
+        name='good_steps', dtype=dtypes.int64, initial_value=0)
+
+  @property
+  def initial_loss_scale(self):
+    return self._initial_loss_scale
+
+  @property
+  def increment_period(self):
+    return self._increment_period
+
+  @property
+  def multiplier(self):
+    return self._multiplier
+
+  def __call__(self):
+    return ops.convert_to_tensor(self._current_loss_scale)
+
+  def update(self, grads):
+    """Updates loss scale based on if gradients are finite in current step."""
+    grads = nest.flatten(grads)
+    if distribute_lib.has_strategy():
+      distribution = distribute_lib.get_cross_replica_context()
+
+      def get_is_finite(grads):
+        is_finite = _is_all_finite(grads)
+        # We cast to float, because we cannot reduce booleans with
+        # DistributionStrategy.
+        return math_ops.cast(is_finite, dtypes.float32)
+
+      is_finite_float = distribution.extended.call_for_each_replica(
+          get_is_finite, args=(grads,))
+      reduced_is_finite_float = distribution.reduce(reduce_util.ReduceOp.SUM,
+                                                    is_finite_float, axis=None)
+      is_finite = math_ops.equal(reduced_is_finite_float,
+                                 distribution.num_replicas_in_sync)
+    else:
+      is_finite = _is_all_finite(grads)
+
+    def update_if_finite_grads():
+      """Update assuming the gradients are finite."""
+
+      def incr_loss_scale():
+        new_loss_scale = self._current_loss_scale * self._multiplier
+        return control_flow_ops.group(
+            _assign_if_finite(self._current_loss_scale, new_loss_scale),
+            self._num_good_steps.assign(0))
+
+      return cond.cond(
+          self._num_good_steps + 1 >= self._increment_period,
+          incr_loss_scale, lambda: _op_in_graph_mode(
+              self._num_good_steps.assign_add(1)))
+
+    def update_if_not_finite_grads():
+      """Update assuming the gradients are nonfinite."""
+
+      new_loss_scale = math_ops.maximum(
+          self._current_loss_scale / self._multiplier, 1)
+      return control_flow_ops.group(
+          self._num_good_steps.assign(0),
+          self._current_loss_scale.assign(new_loss_scale))
+
+    update_op = cond.cond(is_finite, update_if_finite_grads,
+                          update_if_not_finite_grads)
+    should_apply_gradients = is_finite
+    return update_op, should_apply_gradients
+
+  def __repr__(self):
+    if context.executing_eagerly():
+      return ('DynamicLossScale(current_loss_scale=%s, num_good_steps=%s, '
+              'initial_loss_scale=%s, increment_period=%s, multiplier=%s)' %
+              (self._current_loss_scale.numpy(), self._num_good_steps.numpy(),
+               self.initial_loss_scale, self.increment_period, self.multiplier))
+    else:
+      return ('DynamicLossScale(initial_loss_scale=%s, increment_period=%s, '
+              'multiplier=%s)' %
+              (self.initial_loss_scale, self.increment_period, self.multiplier))
+
+  def get_config(self):
+    return {
+        'initial_loss_scale': self.initial_loss_scale,
+        'increment_period': self.increment_period,
+        'multiplier': self.multiplier,
+    }
+
+
+def get(identifier):
+  """Get a loss scale object."""
+  if isinstance(identifier, (int, float)):
+    return FixedLossScale(identifier)
+  if identifier == 'dynamic':
+    return DynamicLossScale()
+  if isinstance(identifier, LossScale):
+    return identifier
+  elif identifier is None:
+    return None
+  else:
+    raise ValueError('Could not interpret loss scale identifier: %s' %
+                     identifier)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/experimental/loss_scale_optimizer.py

@@ -0,0 +1,251 @@
+# 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.
+# ==============================================================================
+"""Contains LossScale classes."""
+from tensorflow.python.distribute import distribute_lib
+from tensorflow.python.framework import indexed_slices
+from tensorflow.python.framework import smart_cond
+from tensorflow.python.ops import control_flow_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.training import optimizer
+from tensorflow.python.training.experimental import loss_scale as loss_scale_module
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated_endpoints(
+    'train.experimental.MixedPrecisionLossScaleOptimizer')
+@tf_export(v1=['mixed_precision.MixedPrecisionLossScaleOptimizer',
+               'train.experimental.MixedPrecisionLossScaleOptimizer'])
+class MixedPrecisionLossScaleOptimizer(optimizer.Optimizer):
+  """An optimizer that applies loss scaling.
+
+  Loss scaling is a process that multiplies the loss by a multiplier called the
+  loss scale, and divides each gradient by the same multiplier. The pseudocode
+  for this process is:
+
+  ```
+  loss = ...
+  loss *= loss_scale
+  grads = gradients(loss, vars)
+  grads /= loss_scale
+  ```
+
+  Mathematically, loss scaling has no effect, but can help avoid numerical
+  underflow in intermediate gradients when float16 tensors are used for mixed
+  precision training. By multiplying the loss, each intermediate gradient will
+  have the same multiplier applied.
+
+  The loss scale can either be a fixed constant, chosen by the user, or be
+  dynamically determined. Dynamically determining the loss scale is convenient
+  as a loss scale does not have to be explicitly chosen. However it reduces
+  performance.
+
+  This optimizer wraps another optimizer and applies loss scaling to it via a
+  `LossScale`. Loss scaling is applied whenever gradients are
+  computed, such as through `minimize()`.
+  """
+
+  def __init__(self, opt, loss_scale):
+    if not isinstance(opt, optimizer.Optimizer):
+      raise ValueError('"opt" must be an instance of Optimizer, but got: %s' %
+                       type(opt))
+    self._optimizer = opt
+
+    use_locking = opt._use_locking  # pylint: disable=protected-access
+    name = opt.get_name()
+    super(MixedPrecisionLossScaleOptimizer, self).__init__(use_locking, name)
+
+    self._loss_scale = loss_scale_module.get(loss_scale)
+    if self._loss_scale is None:
+      raise ValueError('loss_scale cannot be None')
+    self._track_trackable(self._optimizer, 'base_optimizer')
+    self._track_trackable(self._loss_scale, 'loss_scale')
+
+  def _doing_dynamic_loss_scaling(self):
+    """Check if `_loss_scale` dynamically manages the loss scale."""
+    return isinstance(self._loss_scale, loss_scale_module.DynamicLossScale)
+
+  def compute_gradients(self,
+                        loss,
+                        var_list=None,
+                        gate_gradients=optimizer.Optimizer.GATE_OP,
+                        aggregation_method=None,
+                        colocate_gradients_with_ops=False,
+                        grad_loss=None):
+    """Compute gradients of `loss` for the variables in `var_list`.
+
+    This adjusts the dynamic range of the gradient evaluation by scaling up
+    the `loss` value. The gradient values are then scaled back down by the
+    reciprocal of the loss scale. This is useful in reduced precision training
+    where small gradient values would otherwise underflow the representable
+    range.
+
+    Args:
+      loss: A Tensor containing the value to minimize or a callable taking no
+        arguments which returns the value to minimize. When eager execution is
+        enabled it must be a callable.
+      var_list: Optional list or tuple of `tf.Variable` to update to minimize
+        `loss`.  Defaults to the list of variables collected in the graph under
+        the key `GraphKeys.TRAINABLE_VARIABLES`.
+      gate_gradients: How to gate the computation of gradients.  Can be
+        `GATE_NONE`, `GATE_OP`, or `GATE_GRAPH`.
+      aggregation_method: Specifies the method used to combine gradient terms.
+        Valid values are defined in the class `AggregationMethod`.
+      colocate_gradients_with_ops: If True, try colocating gradients with the
+        corresponding op.
+      grad_loss: Optional. A `Tensor` holding the gradient computed for `loss`.
+
+    Returns:
+      A list of (gradient, variable) pairs. Variable is always present, but
+      gradient can be `None`.
+    """
+    loss = self._scale_loss(loss)
+    grads_and_vars = self._optimizer.compute_gradients(
+        loss=loss,
+        var_list=var_list,
+        gate_gradients=gate_gradients,
+        aggregation_method=aggregation_method,
+        colocate_gradients_with_ops=colocate_gradients_with_ops,
+        grad_loss=grad_loss)
+
+    grads = [g for g, _ in grads_and_vars]
+    variables = [v for _, v in grads_and_vars]
+    unscaled_grads = self._unscale_grads(grads)
+    return list(zip(unscaled_grads, variables))
+
+  def _scale_loss(self, loss):
+    loss_scale = self._loss_scale()
+    if callable(loss):
+      def new_loss():
+        loss_val = loss()
+        return loss_val * math_ops.cast(loss_scale, loss_val.dtype)
+      return new_loss
+    else:
+      return loss * math_ops.cast(loss_scale, loss.dtype)
+
+  def _unscale_grads(self, grads):
+    loss_scale = self._loss_scale()
+    loss_scale_reciprocal = 1 / loss_scale
+    return [
+        None if g is None else self._scale_grad(g, loss_scale_reciprocal)
+        for g in grads
+    ]
+
+  def _scale_grad(self, grad, loss_scale_reciprocal):
+    if isinstance(grad, indexed_slices.IndexedSlices):
+      grad_vals = grad.values * loss_scale_reciprocal
+      return indexed_slices.IndexedSlices(grad_vals, grad.indices,
+                                          grad.dense_shape)
+    return grad * loss_scale_reciprocal
+
+  def apply_gradients(self, grads_and_vars, global_step=None, name=None):
+    """Apply gradients to variables.
+
+    This is the second part of `minimize()`. It returns an `Operation` that
+    conditionally applies gradients if all gradient values are finite.
+    Otherwise no update is performed (nor is `global_step` incremented).
+
+    Args:
+      grads_and_vars: List of (gradient, variable) pairs as returned by
+        `compute_gradients()`.
+      global_step: Optional `Variable` to increment by one after the variables
+        have been updated.
+      name: Optional name for the returned operation.  Default to the name
+        passed to the `Optimizer` constructor.
+
+    Returns:
+      An `Operation` that conditionally applies the specified gradients. If
+      `global_step` was not None, that operation also increments `global_step`.
+
+    Raises:
+      RuntimeError: If you should use `_distributed_apply()` instead.
+    """
+    if distribute_lib.in_cross_replica_context():
+      raise ValueError('apply_gradients() must be called in a replica context.')
+
+    if not self._doing_dynamic_loss_scaling():
+      return self._optimizer.apply_gradients(grads_and_vars, global_step, name)
+
+    replica_context = distribute_lib.get_replica_context()
+    grads_and_vars = tuple(grads_and_vars)
+
+    # TODO(nluehr) cleanup GraphKeys.TRAIN_OP
+    return replica_context.merge_call(
+        self._distributed_apply, args=(grads_and_vars, global_step, name))
+
+  def _distributed_apply(self,
+                         distribution,
+                         grads_and_vars,
+                         global_step=None,
+                         name=None):
+    """A version of `apply_gradients` for cross replica context.
+
+    When users are in a cross replica strategy, they must call this rather than
+    `apply_gradients()`.
+
+    Args:
+      distribution: a `DistributionStrategy` object.
+      grads_and_vars: List of (gradient, variable) pairs as returned by
+        `compute_gradients()` and then aggregated across replicas.
+      global_step: Optional (mirrored) `Variable` to increment by one after the
+        variables have been updated.
+      name: Optional name for the returned operation. Default to the name passed
+        to the `Optimizer` constructor.
+
+    Returns:
+      An `Operation` that applies the specified gradients across all
+      replicas. If `global_step` was not None, that operation also
+      increments `global_step`
+    """
+    name = name if name is not None else self.get_name()
+    grads = [g for g, _ in grads_and_vars]
+    loss_scale_update_op, should_apply_grads = (self._loss_scale.update(grads))
+
+    def apply_fn():
+      return self._apply_gradients(distribution, grads_and_vars, global_step,
+                                   name + '-wrapped')
+
+    maybe_apply_op = smart_cond.smart_cond(should_apply_grads, apply_fn,
+                                           control_flow_ops.no_op)
+    return control_flow_ops.group(
+        maybe_apply_op, loss_scale_update_op, name=name)
+
+  def _apply_gradients(self, distribution, grads_and_vars, global_step, name):
+    """Unconditionally apply gradients in cross replica context."""
+    update_ops = distribution.extended.call_for_each_replica(
+        self._optimizer.apply_gradients,
+        args=(grads_and_vars, global_step, name))
+    return distribution.group(update_ops)
+
+  def _apply_sparse(self, grad, var):
+    """This function should never be called."""
+    raise RuntimeError('This function should never be called')
+
+  def _apply_dense(self, grad, var):
+    """This function should never be called."""
+    raise RuntimeError('This function should never be called')
+
+  def _resource_apply_sparse(self, grad, handle, indices):
+    """This function should never be called."""
+    raise RuntimeError('This function should never be called')
+
+  def _resource_apply_dense(self, grad, handle):
+    """This function should never be called."""
+    raise RuntimeError('This function should never be called')
+
+  def variables(self):
+    """Returns the variables of the Optimizer."""
+    return (self._optimizer.variables() +
+            list(self._loss_scale._weights.values()))  # pylint: disable=protected-access

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/python/training/experimental/mixed_precision.py

@@ -0,0 +1,248 @@
+# 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.
+# ==============================================================================
+"""Contains functions to use mixed precision with the graph rewrite."""
+
+from tensorflow.python.framework import config
+from tensorflow.python.platform import tf_logging
+from tensorflow.python.training import optimizer
+from tensorflow.python.training.experimental import loss_scale_optimizer as loss_scale_optimizer_v1
+from tensorflow.python.training.experimental import mixed_precision_global_state
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+# A mapping between optimizers and (wrapper_fn, wrapper_cls) pairs. wrapper_cls
+# is a loss scale optimizer class, and wrapper_fn is a function that takes in
+# an optimizer and LossScale and returns a wrapper_cls instance.
+_REGISTERED_WRAPPER_OPTIMIZER_CLS = {
+    optimizer.Optimizer:
+        (loss_scale_optimizer_v1.MixedPrecisionLossScaleOptimizer,) * 2,
+}
+
+
+@tf_export('__internal__.mixed_precision.register_loss_scale_wrapper', v1=[])
+def register_loss_scale_wrapper(optimizer_cls, wrapper_fn, wrapper_cls=None):
+  """Registers a loss scale optimizer wrapper.
+
+  `tf.compat.v1.mixed_precision.enable_mixed_precision_graph_rewrite`
+  automatically wraps an optimizer with an optimizer wrapper that performs loss
+  scaling. This function registers a
+  `(base_cls, wrapper_fn, wrapper_cls)` triple
+  that is used by `enable_mixed_precision_graph_rewrite`, where
+  `wrapper_fn` is called to create a `wrapper_cls` instance that wraps an
+  `optimizer_cls` instance.
+
+  Args:
+    optimizer_cls: A base optimizer class, e.g. `tf.keras.optimizers.Optimizer`.
+    wrapper_fn: A function that takes in arguments "optimizer" and
+      "loss_scale", and returns a loss scale optimizer of type "wrapper_cls"
+      that wraps "optimizer".
+    wrapper_cls: A loss scale optimizer class. Defaults to `wrapper_fn`, in
+      which case `wrapper_fn` should be a loss scale optimizer class whose
+      constructor takes in arguments "optimizer" and "loss_scale".
+  """
+  _REGISTERED_WRAPPER_OPTIMIZER_CLS[optimizer_cls] = (
+      wrapper_fn, wrapper_cls or wrapper_fn)
+
+
+def _wrap_optimizer(opt, loss_scale):
+  """Wraps an optimizer with a LossScaleOptimizer."""
+
+  for _, wrapper_optimizer in _REGISTERED_WRAPPER_OPTIMIZER_CLS.values():
+    if isinstance(opt, wrapper_optimizer):
+      raise ValueError('"opt" must not already be an instance of a {cls}. '
+                       '`enable_mixed_precision_graph_rewrite` will '
+                       'automatically wrap the optimizer with a '
+                       '{cls}.'
+                       .format(cls=wrapper_optimizer.__name__))
+
+  for optimizer_cls, (wrapper_fn, _) in (
+      _REGISTERED_WRAPPER_OPTIMIZER_CLS.items()):
+    if isinstance(opt, optimizer_cls):
+      return wrapper_fn(opt, loss_scale)
+
+  raise ValueError('"opt" must be an instance of a tf.train.Optimizer or a '
+                   'tf.keras.optimizers.Optimizer, but got: %s' % opt)
+
+
+@deprecation.deprecated_endpoints(
+    'train.experimental.enable_mixed_precision_graph_rewrite')
+@tf_export(v1=['mixed_precision.enable_mixed_precision_graph_rewrite',
+               'train.experimental.enable_mixed_precision_graph_rewrite'])
+def enable_mixed_precision_graph_rewrite_v1(opt, loss_scale='dynamic'):
+  """Enable mixed precision via a graph rewrite.
+
+  Mixed precision is the use of both float32 and float16 data types when
+  training a model to improve performance. This is achieved via a graph rewrite
+  operation and a loss-scale optimizer.
+
+  Performing arithmetic operations in float16 takes advantage of specialized
+  processing units, such as NVIDIA Tensor Cores, for much higher arithmetic
+  throughput. However, due to the smaller representable range, performing the
+  entire training with float16 can result in gradient underflow, that is, small
+  gradient values becoming zeroes. Instead, performing only select arithmetic
+  operations in float16 results in higher throughput and decreased training
+  time when using compatible hardware accelerators while also reducing memory
+  usage, typically without sacrificing model accuracy.
+
+  Note: While the mixed precision rewrite changes the datatype of various
+  layers throughout the model, the same accuracy reached in float32 is
+  expected. If a `NaN` gradient occurs with dynamic loss scaling, the model
+  update for that batch is skipped. In this case, the global step count is not
+  incremented, and the `LossScaleOptimizer` attempts to decrease the loss
+  scaling value to avoid `NaN` values in subsequent iterations. This approach
+  has been shown to achieve the same accuracy as float32 and, in most cases,
+  better training throughput.
+
+  Example:
+
+  ```python
+  model = tf.keras.models.Sequential([
+      tf.keras.layers.Dense(64, activation='relu'),
+      tf.keras.layers.Dense(64, activation='softmax'),
+  ])
+
+  opt = tf.keras.optimizers.SGD()
+  opt = tf.train.experimental.enable_mixed_precision_graph_rewrite(opt)
+  model.compile(loss="mse", optimizer=opt)
+
+  x_train = np.random.random((1024, 64))
+  y_train = np.random.random((1024, 64))
+  model.fit(x_train, y_train)
+  ```
+
+  Calling `enable_mixed_precision_graph_rewrite(opt)` enables the graph rewrite
+  operation before computing gradients. The function additionally returns an
+  `Optimizer` (`opt`) wrapped with a `LossScaleOptimizer`. This prevents
+  underflow in the float16 tensors during the backward pass. An optimizer of
+  type `tf.train.Optimizer` or `tf.keras.optimizers.Optimizer` must be passed
+  to this function, which will then be wrapped to use loss scaling.
+
+  The graph rewrite operation changes the `dtype` of certain operations in the
+  graph from float32 to float16. There are several categories of operations
+  that are either included or excluded by this rewrite operation. The following
+  categories of Ops are defined inside corresponding functions under the class
+  `AutoMixedPrecisionLists` in
+  <a href="https://github.com/tensorflow/tensorflow/blob/master/tensorflow/
+  core/grappler/optimizers/auto_mixed_precision_lists.h">
+  auto_mixed_precision_lists.h</a>:
+
+  * `ClearList`: Ops that do not have numerically significant adverse effects.
+  E.g. `ArgMax` and `Floor`.
+  * `AllowList`: Ops that are considered numerically safe for execution in
+  float16, and thus are always converted. E.g. `Conv2D`.
+  * `DenyList`: Ops that are numerically unsafe to execute in float16 and
+  can negatively affect downstream nodes. E.g. `Softmax`.
+  * `GrayList`: Ops that are considered numerically safe for execution in
+  float16 unless downstream from a DenyList Op. E.g. `Add` and `AvgPool`.
+
+  When this function is used, gradients should only be computed and applied
+  with the returned optimizer, either by calling `opt.minimize()` or
+  `opt.compute_gradients()` followed by `opt.apply_gradients()`.
+  Gradients should not be computed with `tf.gradients` or `tf.GradientTape`.
+  This is because the returned optimizer will apply loss scaling, and
+  `tf.gradients` or `tf.GradientTape` will not. If you do directly use
+  `tf.gradients` or `tf.GradientTape`, your model may not converge due to
+  float16 underflow problems.
+
+  When eager execution is enabled, the mixed precision graph rewrite is only
+  enabled within `tf.function`s, as outside `tf.function`s, there is no graph.
+
+  For NVIDIA GPUs with Tensor cores, as a general performance guide, dimensions
+  (such as batch size, input size, output size, and channel counts)
+  should be powers of two if under 256, or  otherwise divisible by 8 if above
+  256. For more information, check out the
+  [NVIDIA Deep Learning Performance Guide](
+  https://docs.nvidia.com/deeplearning/sdk/dl-performance-guide/index.html).
+
+  Currently, mixed precision is only enabled on NVIDIA Tensor Core GPUs with
+  Compute Capability 7.0 and above (Volta, Turing, or newer architectures). The
+  parts of the graph on CPUs and TPUs are untouched by the graph rewrite.
+
+  Raises:
+    `ValueError`, if the `tf.keras.mixed_precision` API is also used by calling
+    `tf.keras.mixed_precision.set_global_policy`. Only one mixed precision
+    API can be used.
+
+  Args:
+    opt: An instance of a `tf.keras.optimizers.Optimizer` or a
+      `tf.train.Optimizer`.
+    loss_scale: Either an int/float, the string `"dynamic"`, or an instance of
+      a `tf.mixed_precision.experimental.LossScale`. The loss scale to use. It
+      is recommended to keep this as its default value of `"dynamic"`, which
+      will adjust the scaling automatically to prevent `Inf` or `NaN` values.
+
+  Returns:
+    A version of `opt` that will use loss scaling to prevent underflow.
+  """
+  if mixed_precision_global_state.is_using_mixed_precision_policy():
+    raise ValueError(
+        'The mixed precision graph rewrite cannot be enabled, because the '
+        'global Keras dtype Policy has been set to a mixed precision policy. '
+        'At most, one of the following can be called:\n\n'
+        '  1. tf.keras.mixed_precision.set_global_policy() with a mixed '
+        'precision policy (You called this first)\n\n'
+        '  2. tf.train.experimental.enable_mixed_precision_graph_rewrite() '
+        '(You called this second)\n'
+        'You called both functions, which is an error, because both functions '
+        'enable you to use mixed precision. If in doubt which function to use, '
+        'use the first, as it supports Eager execution and is more '
+        'customizable.')
+
+  if mixed_precision_global_state.non_mixed_precision_session_created():
+    # TODO(reedwm): Give the stacktrace of the existing Sessions. And if the
+    # Sessions have already been closed, do not raise this error message.
+    tf_logging.warn('You already have existing Sessions that do not use mixed '
+                    'precision. enable_mixed_precision_graph_rewrite() will '
+                    'not affect these Sessions.')
+  opt = _wrap_optimizer(opt, loss_scale)
+  config.set_optimizer_experimental_options({'auto_mixed_precision': True})
+  mixed_precision_global_state.set_mixed_precision_graph_rewrite_enabled(True)
+  return opt
+
+
+@deprecation.deprecated_endpoints(
+    'train.experimental.disable_mixed_precision_graph_rewrite')
+@tf_export(v1=['mixed_precision.disable_mixed_precision_graph_rewrite',
+               'train.experimental.disable_mixed_precision_graph_rewrite'])
+def disable_mixed_precision_graph_rewrite_v1():
+  """Disables the mixed precision graph rewrite.
+
+  After this is called, the mixed precision graph rewrite will no longer run for
+  new Sessions, and so float32 operations will no longer be converted to float16
+  in such Sessions. However, any existing Sessions will continue to have the
+  graph rewrite enabled if they were created after
+  `enable_mixed_precision_graph_rewrite` was called but before
+  `disable_mixed_precision_graph_rewrite` was called.
+
+  This does not undo the effects of loss scaling. Any optimizers wrapped with a
+  LossScaleOptimizer will continue to do loss scaling, although this loss
+  scaling will no longer be useful if the optimizer is used in new Sessions, as
+  the graph rewrite no longer converts the graph to use float16.
+
+  This function is useful for unit testing. A unit tests can test using the
+  mixed precision graph rewrite, then disable it so future unit tests continue
+  using float32. If this is done, unit tests should not share a single session,
+  as `enable_mixed_precision_graph_rewrite` and
+  `disable_mixed_precision_graph_rewrite` have no effect on existing sessions.
+  """
+  # We only have a separate V1 version of this function, because the V1
+  # docstring mentions sessions.
+  if (not
+      mixed_precision_global_state.is_mixed_precision_graph_rewrite_enabled()):
+    tf_logging.warn('disable_mixed_precision_graph_rewrite() called when mixed '
+                    'precision is already disabled.')
+  config.set_optimizer_experimental_options({'auto_mixed_precision': False})
+  mixed_precision_global_state.set_mixed_precision_graph_rewrite_enabled(False)