Add files using upload-large-folder tool

.gitattributes

@@ -810,3 +810,4 @@ videochat2/lib/python3.10/site-packages/tensorflow/python/_pywrap_py_exception_r
 videochat2/lib/python3.10/site-packages/tensorflow/python/_pywrap_tfcompile.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/flags_pybind.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/_pywrap_quantize_training.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/_pywrap_toco_api.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/site-packages/torch/mtia/_utils.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import torch
+
+# The _get_device_index has been moved to torch.utils._get_device_index
+from torch._utils import _get_device_index as _torch_get_device_index
+
+
+def _get_device_index(
+    device: Any, optional: bool = False, allow_cpu: bool = False
+) -> int:
+    r"""Get the device index from :attr:`device`, which can be a torch.device object, a Python integer, or ``None``.
+
+    If :attr:`device` is a torch.device object, returns the device index if it
+    is a MTIA device. Note that for a MTIA device without a specified index,
+    i.e., ``torch.device('mtia')``, this will return the current default MTIA
+    device if :attr:`optional` is ``True``. If :attr:`allow_cpu` is ``True``,
+    CPU devices will be accepted and ``-1`` will be returned in this case.
+
+    If :attr:`device` is a Python integer, it is returned as is.
+
+    If :attr:`device` is ``None``, this will return the current default MTIA
+    device if :attr:`optional` is ``True``.
+    """
+    if isinstance(device, int):
+        return device
+    if isinstance(device, str):
+        device = torch.device(device)
+    if isinstance(device, torch.device):
+        if allow_cpu:
+            if device.type not in ["mtia", "cpu"]:
+                raise ValueError(f"Expected a mtia or cpu device, but got: {device}")
+        elif device.type != "mtia":
+            raise ValueError(f"Expected a mtia device, but got: {device}")
+    if not torch.jit.is_scripting():
+        if isinstance(device, torch.mtia.device):
+            return device.idx
+    return _torch_get_device_index(device, optional, allow_cpu)

parrot/lib/python3.10/site-packages/torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/CMakeInitializeConfigs.cmake

@@ -0,0 +1,40 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# Present in upstream, but not supported on versions of cmake we need to support
+# include_guard(GLOBAL)
+
+# Initializes `<_PREFIX>_<CONFIG>` variables from the corresponding
+# `<_PREFIX>_<CONFIG>_INIT`, for the configurations currently used.
+function(cmake_initialize_per_config_variable _PREFIX _DOCSTRING)
+  string(STRIP "${${_PREFIX}_INIT}" _INIT)
+  set("${_PREFIX}" "${_INIT}"
+    CACHE STRING "${_DOCSTRING} during all build types.")
+  mark_as_advanced("${_PREFIX}")
+
+  if (NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+    set(_CONFIGS Debug Release MinSizeRel RelWithDebInfo)
+
+    get_property(_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+    if (_GENERATOR_IS_MULTI_CONFIG)
+      list(APPEND _CONFIGS ${CMAKE_CONFIGURATION_TYPES})
+    else()
+      if (NOT CMAKE_NO_BUILD_TYPE)
+        set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE_INIT}" CACHE STRING
+          "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel ...")
+      endif()
+      list(APPEND _CONFIGS ${CMAKE_BUILD_TYPE})
+    endif()
+
+    list(REMOVE_DUPLICATES _CONFIGS)
+    foreach(_BUILD_TYPE IN LISTS _CONFIGS)
+      if (NOT "${_BUILD_TYPE}" STREQUAL "")
+        string(TOUPPER "${_BUILD_TYPE}" _BUILD_TYPE)
+        string(STRIP "${${_PREFIX}_${_BUILD_TYPE}_INIT}" _INIT)
+        set("${_PREFIX}_${_BUILD_TYPE}" "${_INIT}"
+          CACHE STRING "${_DOCSTRING} during ${_BUILD_TYPE} builds.")
+        mark_as_advanced("${_PREFIX}_${_BUILD_TYPE}")
+      endif()
+    endforeach()
+  endif()
+endfunction()

parrot/lib/python3.10/site-packages/torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/parse_cubin.cmake

@@ -0,0 +1,109 @@
+#  James Bigler, NVIDIA Corp (nvidia.com - jbigler)
+#  Abe Stephens, SCI Institute -- http://www.sci.utah.edu/~abe/FindCuda.html
+#
+#  Copyright (c) 2008 - 2009 NVIDIA Corporation.  All rights reserved.
+#
+#  Copyright (c) 2007-2009
+#  Scientific Computing and Imaging Institute, University of Utah
+#
+#  This code is licensed under the MIT License.  See the FindCUDA.cmake script
+#  for the text of the license.
+
+# The MIT License
+#
+# License for the specific language governing rights and limitations under
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+#
+
+#######################################################################
+# Parses a .cubin file produced by nvcc and reports statistics about the file.
+
+
+file(READ ${input_file} file_text)
+
+if (NOT "${file_text}" STREQUAL "")
+
+  string(REPLACE ";" "\\;" file_text ${file_text})
+  string(REPLACE "\ncode" ";code" file_text ${file_text})
+
+  list(LENGTH file_text len)
+
+  foreach(line ${file_text})
+
+    # Only look at "code { }" blocks.
+    if(line MATCHES "^code")
+
+      # Break into individual lines.
+      string(REGEX REPLACE "\n" ";" line ${line})
+
+      foreach(entry ${line})
+
+        # Extract kernel names.
+        if (${entry} MATCHES "[^g]name = ([^ ]+)")
+          set(entry "${CMAKE_MATCH_1}")
+
+          # Check to see if the kernel name starts with "_"
+          set(skip FALSE)
+          # if (${entry} MATCHES "^_")
+            # Skip the rest of this block.
+            # message("Skipping ${entry}")
+            # set(skip TRUE)
+          # else ()
+            message("Kernel:    ${entry}")
+          # endif ()
+
+        endif()
+
+        # Skip the rest of the block if necessary
+        if(NOT skip)
+
+          # Registers
+          if (${entry} MATCHES "reg([ ]+)=([ ]+)([^ ]+)")
+            set(entry "${CMAKE_MATCH_3}")
+            message("Registers: ${entry}")
+          endif()
+
+          # Local memory
+          if (${entry} MATCHES "lmem([ ]+)=([ ]+)([^ ]+)")
+            set(entry "${CMAKE_MATCH_3}")
+            message("Local:     ${entry}")
+          endif()
+
+          # Shared memory
+          if (${entry} MATCHES "smem([ ]+)=([ ]+)([^ ]+)")
+            set(entry "${CMAKE_MATCH_3}")
+            message("Shared:    ${entry}")
+          endif()
+
+          if (${entry} MATCHES "^}")
+            message("")
+          endif()
+
+        endif()
+
+
+      endforeach()
+
+    endif()
+
+  endforeach()
+
+else()
+  # message("FOUND NO DEPENDS")
+endif()

parrot/lib/python3.10/site-packages/torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/run_nvcc.cmake

@@ -0,0 +1,303 @@
+#  James Bigler, NVIDIA Corp (nvidia.com - jbigler)
+#
+#  Copyright (c) 2008 - 2009 NVIDIA Corporation.  All rights reserved.
+#
+#  This code is licensed under the MIT License.  See the FindCUDA.cmake script
+#  for the text of the license.
+
+# The MIT License
+#
+# License for the specific language governing rights and limitations under
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+
+##########################################################################
+# This file runs the nvcc commands to produce the desired output file along with
+# the dependency file needed by CMake to compute dependencies.  In addition the
+# file checks the output of each command and if the command fails it deletes the
+# output files.
+
+# Input variables
+#
+# verbose:BOOL=<>          OFF: Be as quiet as possible (default)
+#                          ON : Describe each step
+#
+# build_configuration:STRING=<> Typically one of Debug, MinSizeRel, Release, or
+#                               RelWithDebInfo, but it should match one of the
+#                               entries in CUDA_HOST_FLAGS. This is the build
+#                               configuration used when compiling the code.  If
+#                               blank or unspecified Debug is assumed as this is
+#                               what CMake does.
+#
+# generated_file:STRING=<> File to generate.  This argument must be passed in.
+#
+# generated_cubin_file:STRING=<> File to generate.  This argument must be passed
+#                                                   in if build_cubin is true.
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0007 NEW)
+cmake_policy(SET CMP0010 NEW)
+if(NOT generated_file)
+  message(FATAL_ERROR "You must specify generated_file on the command line")
+endif()
+
+# Set these up as variables to make reading the generated file easier
+set(CMAKE_COMMAND "@CMAKE_COMMAND@") # path
+set(source_file "@source_file@") # path
+set(NVCC_generated_dependency_file "@NVCC_generated_dependency_file@") # path
+set(cmake_dependency_file "@cmake_dependency_file@") # path
+set(CUDA_make2cmake "@CUDA_make2cmake@") # path
+set(CUDA_parse_cubin "@CUDA_parse_cubin@") # path
+set(build_cubin @build_cubin@) # bool
+set(CUDA_HOST_COMPILER "@CUDA_HOST_COMPILER@") # path
+# We won't actually use these variables for now, but we need to set this, in
+# order to force this file to be run again if it changes.
+set(generated_file_path "@generated_file_path@") # path
+set(generated_file_internal "@generated_file@") # path
+set(generated_cubin_file_internal "@generated_cubin_file@") # path
+
+set(CUDA_NVCC_EXECUTABLE "@CUDA_NVCC_EXECUTABLE@") # path
+set(CUDA_NVCC_FLAGS @CUDA_NVCC_FLAGS@ ;; @CUDA_WRAP_OPTION_NVCC_FLAGS@) # list
+@CUDA_NVCC_FLAGS_CONFIG@
+set(nvcc_flags @nvcc_flags@) # list
+set(CUDA_NVCC_INCLUDE_DIRS [==[@CUDA_NVCC_INCLUDE_DIRS@]==]) # list (needs to be in lua quotes to address backslashes)
+string(REPLACE "\\" "/" CUDA_NVCC_INCLUDE_DIRS "${CUDA_NVCC_INCLUDE_DIRS}")
+set(CUDA_NVCC_COMPILE_DEFINITIONS [==[@CUDA_NVCC_COMPILE_DEFINITIONS@]==]) # list (needs to be in lua quotes see #16510 ).
+set(format_flag "@format_flag@") # string
+set(cuda_language_flag @cuda_language_flag@) # list
+
+# Clean up list of include directories and add -I flags
+list(REMOVE_DUPLICATES CUDA_NVCC_INCLUDE_DIRS)
+set(CUDA_NVCC_INCLUDE_ARGS)
+foreach(dir ${CUDA_NVCC_INCLUDE_DIRS})
+  # Extra quotes are added around each flag to help nvcc parse out flags with spaces.
+  list(APPEND CUDA_NVCC_INCLUDE_ARGS "-I${dir}")
+endforeach()
+
+# Clean up list of compile definitions, add -D flags, and append to nvcc_flags
+list(REMOVE_DUPLICATES CUDA_NVCC_COMPILE_DEFINITIONS)
+foreach(def ${CUDA_NVCC_COMPILE_DEFINITIONS})
+  list(APPEND nvcc_flags "-D${def}")
+endforeach()
+
+if(build_cubin AND NOT generated_cubin_file)
+  message(FATAL_ERROR "You must specify generated_cubin_file on the command line")
+endif()
+
+# This is the list of host compilation flags.  It C or CXX should already have
+# been chosen by FindCUDA.cmake.
+@CUDA_HOST_FLAGS@
+
+# Take the compiler flags and package them up to be sent to the compiler via -Xcompiler
+set(nvcc_host_compiler_flags "")
+# If we weren't given a build_configuration, use Debug.
+if(NOT build_configuration)
+  set(build_configuration Debug)
+endif()
+string(TOUPPER "${build_configuration}" build_configuration)
+#message("CUDA_NVCC_HOST_COMPILER_FLAGS = ${CUDA_NVCC_HOST_COMPILER_FLAGS}")
+foreach(flag ${CMAKE_HOST_FLAGS} ${CMAKE_HOST_FLAGS_${build_configuration}})
+  # Extra quotes are added around each flag to help nvcc parse out flags with spaces.
+  string(APPEND nvcc_host_compiler_flags ",\"${flag}\"")
+endforeach()
+if (nvcc_host_compiler_flags)
+  set(nvcc_host_compiler_flags "-Xcompiler" ${nvcc_host_compiler_flags})
+endif()
+#message("nvcc_host_compiler_flags = \"${nvcc_host_compiler_flags}\"")
+# Add the build specific configuration flags
+list(APPEND CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS_${build_configuration}})
+
+# Any -ccbin existing in CUDA_NVCC_FLAGS gets highest priority
+list( FIND CUDA_NVCC_FLAGS "-ccbin" ccbin_found0 )
+list( FIND CUDA_NVCC_FLAGS "--compiler-bindir" ccbin_found1 )
+if( ccbin_found0 LESS 0 AND ccbin_found1 LESS 0 AND CUDA_HOST_COMPILER )
+  if (CUDA_HOST_COMPILER STREQUAL "@_CUDA_MSVC_HOST_COMPILER@" AND DEFINED CCBIN)
+    set(CCBIN -ccbin "${CCBIN}")
+  else()
+    set(CCBIN -ccbin "${CUDA_HOST_COMPILER}")
+  endif()
+endif()
+
+# cuda_execute_process - Executes a command with optional command echo and status message.
+#
+#   status  - Status message to print if verbose is true
+#   command - COMMAND argument from the usual execute_process argument structure
+#   ARGN    - Remaining arguments are the command with arguments
+#
+#   CUDA_result - return value from running the command
+#
+# Make this a macro instead of a function, so that things like RESULT_VARIABLE
+# and other return variables are present after executing the process.
+macro(cuda_execute_process status command)
+  set(_command ${command})
+  if(NOT "x${_command}" STREQUAL "xCOMMAND")
+    message(FATAL_ERROR "Malformed call to cuda_execute_process.  Missing COMMAND as second argument. (command = ${command})")
+  endif()
+  if(verbose)
+    execute_process(COMMAND "${CMAKE_COMMAND}" -E echo -- ${status})
+    # Now we need to build up our command string.  We are accounting for quotes
+    # and spaces, anything else is left up to the user to fix if they want to
+    # copy and paste a runnable command line.
+    set(cuda_execute_process_string)
+    foreach(arg ${ARGN})
+      # If there are quotes, excape them, so they come through.
+      string(REPLACE "\"" "\\\"" arg ${arg})
+      # Args with spaces need quotes around them to get them to be parsed as a single argument.
+      if(arg MATCHES " ")
+        list(APPEND cuda_execute_process_string "\"${arg}\"")
+      else()
+        list(APPEND cuda_execute_process_string ${arg})
+      endif()
+    endforeach()
+    # Echo the command
+    execute_process(COMMAND ${CMAKE_COMMAND} -E echo ${cuda_execute_process_string})
+  endif()
+  # Run the command
+  execute_process(COMMAND ${ARGN} RESULT_VARIABLE CUDA_result )
+endmacro()
+
+# Delete the target file
+cuda_execute_process(
+  "Removing ${generated_file}"
+  COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
+  )
+
+# For CUDA 2.3 and below, -G -M doesn't work, so remove the -G flag
+# for dependency generation and hope for the best.
+set(depends_CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}")
+set(CUDA_VERSION @CUDA_VERSION@)
+
+# nvcc doesn't define __CUDACC__ for some reason when generating dependency files.  This
+# can cause incorrect dependencies when #including files based on this macro which is
+# defined in the generating passes of nvcc invocation.  We will go ahead and manually
+# define this for now until a future version fixes this bug.
+set(CUDACC_DEFINE -D__CUDACC__)
+
+# Generate the dependency file
+cuda_execute_process(
+  "Generating dependency file: ${NVCC_generated_dependency_file}"
+  COMMAND "${CUDA_NVCC_EXECUTABLE}"
+  -M
+  ${CUDACC_DEFINE}
+  "${source_file}"
+  -o "${NVCC_generated_dependency_file}"
+  ${CCBIN}
+  ${nvcc_flags}
+  ${nvcc_host_compiler_flags}
+  ${depends_CUDA_NVCC_FLAGS}
+  -DNVCC
+  ${CUDA_NVCC_INCLUDE_ARGS}
+  )
+
+if(CUDA_result)
+  message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Generate the cmake readable dependency file to a temp file.  Don't put the
+# quotes just around the filenames for the input_file and output_file variables.
+# CMake will pass the quotes through and not be able to find the file.
+cuda_execute_process(
+  "Generating temporary cmake readable file: ${cmake_dependency_file}.tmp"
+  COMMAND "${CMAKE_COMMAND}"
+  -D "input_file:FILEPATH=${NVCC_generated_dependency_file}"
+  -D "output_file:FILEPATH=${cmake_dependency_file}.tmp"
+  -D "verbose=${verbose}"
+  -P "${CUDA_make2cmake}"
+  )
+
+if(CUDA_result)
+  message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Copy the file if it is different
+cuda_execute_process(
+  "Copy if different ${cmake_dependency_file}.tmp to ${cmake_dependency_file}"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${cmake_dependency_file}.tmp" "${cmake_dependency_file}"
+  )
+
+if(CUDA_result)
+  message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Delete the temporary file
+cuda_execute_process(
+  "Removing ${cmake_dependency_file}.tmp and ${NVCC_generated_dependency_file}"
+  COMMAND "${CMAKE_COMMAND}" -E remove "${cmake_dependency_file}.tmp" "${NVCC_generated_dependency_file}"
+  )
+
+if(CUDA_result)
+  message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Generate the code
+cuda_execute_process(
+  "Generating ${generated_file}"
+  COMMAND "${CUDA_NVCC_EXECUTABLE}"
+  "${source_file}"
+  ${cuda_language_flag}
+  ${format_flag} -o "${generated_file}"
+  ${CCBIN}
+  ${nvcc_flags}
+  ${nvcc_host_compiler_flags}
+  ${CUDA_NVCC_FLAGS}
+  -DNVCC
+  ${CUDA_NVCC_INCLUDE_ARGS}
+  )
+
+if(CUDA_result)
+  # Since nvcc can sometimes leave half done files make sure that we delete the output file.
+  cuda_execute_process(
+    "Removing ${generated_file}"
+    COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
+    )
+  message(FATAL_ERROR "Error generating file ${generated_file}")
+else()
+  if(verbose)
+    message("Generated ${generated_file} successfully.")
+  endif()
+endif()
+
+# Cubin resource report commands.
+if( build_cubin )
+  # Run with -cubin to produce resource usage report.
+  cuda_execute_process(
+    "Generating ${generated_cubin_file}"
+    COMMAND "${CUDA_NVCC_EXECUTABLE}"
+    "${source_file}"
+    ${CUDA_NVCC_FLAGS}
+    ${nvcc_flags}
+    ${CCBIN}
+    ${nvcc_host_compiler_flags}
+    -DNVCC
+    -cubin
+    -o "${generated_cubin_file}"
+    ${CUDA_NVCC_INCLUDE_ARGS}
+    )
+
+  # Execute the parser script.
+  cuda_execute_process(
+    "Executing the parser script"
+    COMMAND  "${CMAKE_COMMAND}"
+    -D "input_file:STRING=${generated_cubin_file}"
+    -P "${CUDA_parse_cubin}"
+    )
+
+endif()
+
+cmake_policy(POP)

parrot/lib/python3.10/site-packages/torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/select_compute_arch.cmake

@@ -0,0 +1,280 @@
+# Synopsis:
+#   CUDA_SELECT_NVCC_ARCH_FLAGS(out_variable [target_CUDA_architectures])
+#   -- Selects GPU arch flags for nvcc based on target_CUDA_architectures
+#      target_CUDA_architectures : Auto | Common | All | LIST(ARCH_AND_PTX ...)
+#       - "Auto" detects local machine GPU compute arch at runtime.
+#       - "Common" and "All" cover common and entire subsets of architectures
+#      ARCH_AND_PTX : NAME | NUM.NUM | NUM.NUM(NUM.NUM) | NUM.NUM+PTX
+#      NAME: Kepler Maxwell Kepler+Tegra Kepler+Tesla Maxwell+Tegra Pascal Volta Turing Ampere
+#      NUM: Any number. Only those pairs are currently accepted by NVCC though:
+#            3.5 3.7 5.0 5.2 5.3 6.0 6.2 7.0 7.2 7.5 8.0
+#      Returns LIST of flags to be added to CUDA_NVCC_FLAGS in ${out_variable}
+#      Additionally, sets ${out_variable}_readable to the resulting numeric list
+#      Example:
+#       CUDA_SELECT_NVCC_ARCH_FLAGS(ARCH_FLAGS 3.0 3.5+PTX 5.2(5.0) Maxwell)
+#        LIST(APPEND CUDA_NVCC_FLAGS ${ARCH_FLAGS})
+#
+#      More info on CUDA architectures: https://en.wikipedia.org/wiki/CUDA
+#
+
+if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
+  if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA"
+      AND CMAKE_CUDA_COMPILER_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
+    set(CUDA_VERSION "${CMAKE_MATCH_1}")
+  endif()
+endif()
+
+# See: https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list
+
+# This list will be used for CUDA_ARCH_NAME = All option
+set(CUDA_KNOWN_GPU_ARCHITECTURES  "Kepler" "Maxwell")
+
+# This list will be used for CUDA_ARCH_NAME = Common option (enabled by default)
+set(CUDA_COMMON_GPU_ARCHITECTURES "3.5" "5.0")
+
+# This list is used to filter CUDA archs when autodetecting
+set(CUDA_ALL_GPU_ARCHITECTURES "3.5" "5.0")
+
+if(CUDA_VERSION VERSION_GREATER "10.5")
+  list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Ampere")
+  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.0")
+  list(APPEND CUDA_ALL_GPU_ARCHITECTURES "8.0")
+
+  if(CUDA_VERSION VERSION_LESS "11.1")
+    set(CUDA_LIMIT_GPU_ARCHITECTURE "8.0")
+    list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.0+PTX")
+  endif()
+endif()
+
+if(NOT CUDA_VERSION VERSION_LESS "11.1")
+  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.6")
+  list(APPEND CUDA_ALL_GPU_ARCHITECTURES "8.6")
+  set(CUDA_LIMIT_GPU_ARCHITECUTRE "8.6")
+
+  if(CUDA_VERSION VERSION_LESS "11.8")
+    set(CUDA_LIMIT_GPU_ARCHITECTURE "8.9")
+    list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.6+PTX")
+  endif()
+endif()
+
+if(NOT CUDA_VERSION VERSION_LESS "11.8")
+  list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Ada")
+  list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Hopper")
+  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.9")
+  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "9.0")
+  list(APPEND CUDA_ALL_GPU_ARCHITECTURES "8.9")
+  list(APPEND CUDA_ALL_GPU_ARCHITECTURES "9.0")
+
+  if(CUDA_VERSION VERSION_LESS "12.0")
+    set(CUDA_LIMIT_GPU_ARCHITECTURE "9.0")
+    list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "8.9+PTX")
+    list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "9.0+PTX")
+  endif()
+endif()
+
+if(NOT CUDA_VERSION VERSION_LESS "12.0")
+  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "9.0a")
+  list(APPEND CUDA_ALL_GPU_ARCHITECTURES "9.0a")
+  list(REMOVE_ITEM CUDA_COMMON_GPU_ARCHITECTURES "3.5")
+  list(REMOVE_ITEM CUDA_ALL_GPU_ARCHITECTURES "3.5")
+endif()
+
+################################################################################################
+# A function for automatic detection of GPUs installed  (if autodetection is enabled)
+# Usage:
+#   CUDA_DETECT_INSTALLED_GPUS(OUT_VARIABLE)
+#
+function(CUDA_DETECT_INSTALLED_GPUS OUT_VARIABLE)
+  if(NOT CUDA_GPU_DETECT_OUTPUT)
+    if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
+      set(file "${PROJECT_BINARY_DIR}/detect_cuda_compute_capabilities.cu")
+    else()
+      set(file "${PROJECT_BINARY_DIR}/detect_cuda_compute_capabilities.cpp")
+    endif()
+
+    file(WRITE ${file} ""
+      "#include <cuda_runtime.h>\n"
+      "#include <cstdio>\n"
+      "int main()\n"
+      "{\n"
+      "  int count = 0;\n"
+      "  if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"
+      "  if (count == 0) return -1;\n"
+      "  for (int device = 0; device < count; ++device)\n"
+      "  {\n"
+      "    cudaDeviceProp prop;\n"
+      "    if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"
+      "      std::printf(\"%d.%d \", prop.major, prop.minor);\n"
+      "  }\n"
+      "  return 0;\n"
+      "}\n")
+
+    if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
+      try_run(run_result compile_result ${PROJECT_BINARY_DIR} ${file}
+              RUN_OUTPUT_VARIABLE compute_capabilities)
+    else()
+      try_run(run_result compile_result ${PROJECT_BINARY_DIR} ${file}
+              CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CUDA_INCLUDE_DIRS}"
+              LINK_LIBRARIES ${CUDA_LIBRARIES}
+              RUN_OUTPUT_VARIABLE compute_capabilities)
+    endif()
+
+    # Filter unrelated content out of the output.
+    string(REGEX MATCHALL "[0-9]+\\.[0-9]+" compute_capabilities "${compute_capabilities}")
+
+    if(run_result EQUAL 0)
+      string(REPLACE "2.1" "2.1(2.0)" compute_capabilities "${compute_capabilities}")
+      set(CUDA_GPU_DETECT_OUTPUT ${compute_capabilities}
+        CACHE INTERNAL "Returned GPU architectures from detect_gpus tool" FORCE)
+    endif()
+  endif()
+
+  if(NOT CUDA_GPU_DETECT_OUTPUT)
+    message(STATUS "Automatic GPU detection failed. Building for common architectures.")
+    set(${OUT_VARIABLE} ${CUDA_COMMON_GPU_ARCHITECTURES} PARENT_SCOPE)
+  else()
+    # Filter based on CUDA version supported archs
+    set(CUDA_GPU_DETECT_OUTPUT_FILTERED "")
+    separate_arguments(CUDA_GPU_DETECT_OUTPUT)
+    foreach(ITEM IN ITEMS ${CUDA_GPU_DETECT_OUTPUT})
+        if(CUDA_LIMIT_GPU_ARCHITECTURE AND (ITEM VERSION_GREATER CUDA_LIMIT_GPU_ARCHITECTURE OR
+                                            ITEM VERSION_EQUAL CUDA_LIMIT_GPU_ARCHITECTURE))
+        list(GET CUDA_COMMON_GPU_ARCHITECTURES -1 NEWITEM)
+        string(APPEND CUDA_GPU_DETECT_OUTPUT_FILTERED " ${NEWITEM}")
+      else()
+        string(APPEND CUDA_GPU_DETECT_OUTPUT_FILTERED " ${ITEM}")
+      endif()
+    endforeach()
+
+    set(${OUT_VARIABLE} ${CUDA_GPU_DETECT_OUTPUT_FILTERED} PARENT_SCOPE)
+  endif()
+endfunction()
+
+
+################################################################################################
+# Function for selecting GPU arch flags for nvcc based on CUDA architectures from parameter list
+# Usage:
+#   SELECT_NVCC_ARCH_FLAGS(out_variable [list of CUDA compute archs])
+function(CUDA_SELECT_NVCC_ARCH_FLAGS out_variable)
+  set(CUDA_ARCH_LIST "${ARGN}")
+
+  if("X${CUDA_ARCH_LIST}" STREQUAL "X" )
+    set(CUDA_ARCH_LIST "Auto")
+  endif()
+
+  set(cuda_arch_bin)
+  set(cuda_arch_ptx)
+
+  if("${CUDA_ARCH_LIST}" STREQUAL "All")
+    set(CUDA_ARCH_LIST ${CUDA_KNOWN_GPU_ARCHITECTURES})
+  elseif("${CUDA_ARCH_LIST}" STREQUAL "Common")
+    set(CUDA_ARCH_LIST ${CUDA_COMMON_GPU_ARCHITECTURES})
+  elseif("${CUDA_ARCH_LIST}" STREQUAL "Auto")
+    CUDA_DETECT_INSTALLED_GPUS(CUDA_ARCH_LIST)
+    message(STATUS "Autodetected CUDA architecture(s): ${CUDA_ARCH_LIST}")
+  endif()
+
+  # Now process the list and look for names
+  string(REGEX REPLACE "[ \t]+" ";" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
+  list(REMOVE_DUPLICATES CUDA_ARCH_LIST)
+  foreach(arch_name ${CUDA_ARCH_LIST})
+    set(arch_bin)
+    set(arch_ptx)
+    set(add_ptx FALSE)
+    # Check to see if we are compiling PTX
+    if(arch_name MATCHES "(.*)\\+PTX$")
+      set(add_ptx TRUE)
+      set(arch_name ${CMAKE_MATCH_1})
+    endif()
+    if(arch_name MATCHES "^([0-9]\\.[0-9]a?(\\([0-9]\\.[0-9]\\))?)$")
+      set(arch_bin ${CMAKE_MATCH_1})
+      set(arch_ptx ${arch_bin})
+    else()
+      # Look for it in our list of known architectures
+      if(${arch_name} STREQUAL "Kepler+Tesla")
+        set(arch_bin 3.7)
+      elseif(${arch_name} STREQUAL "Kepler")
+        set(arch_bin 3.5)
+        set(arch_ptx 3.5)
+      elseif(${arch_name} STREQUAL "Maxwell+Tegra")
+        set(arch_bin 5.3)
+      elseif(${arch_name} STREQUAL "Maxwell")
+        set(arch_bin 5.0 5.2)
+        set(arch_ptx 5.2)
+      elseif(${arch_name} STREQUAL "Pascal")
+        set(arch_bin 6.0 6.1)
+        set(arch_ptx 6.1)
+     elseif(${arch_name} STREQUAL "Volta+Tegra")
+        set(arch_bin 7.2)
+      elseif(${arch_name} STREQUAL "Volta")
+        set(arch_bin 7.0 7.0)
+        set(arch_ptx 7.0)
+      elseif(${arch_name} STREQUAL "Turing")
+        set(arch_bin 7.5)
+        set(arch_ptx 7.5)
+      elseif(${arch_name} STREQUAL "Ampere+Tegra")
+        set(arch_bin 8.7)
+      elseif(${arch_name} STREQUAL "Ampere")
+        set(arch_bin 8.0 8.6)
+        set(arch_ptx 8.0 8.6)
+      elseif(${arch_name} STREQUAL "Ada")
+        set(arch_bin 8.9)
+        set(arch_ptx 8.9)
+      elseif(${arch_name} STREQUAL "Hopper")
+        set(arch_bin 9.0)
+        set(arch_ptx 9.0)
+      else()
+        message(SEND_ERROR "Unknown CUDA Architecture Name ${arch_name} in CUDA_SELECT_NVCC_ARCH_FLAGS")
+      endif()
+    endif()
+    if(NOT arch_bin)
+      message(SEND_ERROR "arch_bin wasn't set for some reason")
+    endif()
+    list(APPEND cuda_arch_bin ${arch_bin})
+    if(add_ptx)
+      if (NOT arch_ptx)
+        set(arch_ptx ${arch_bin})
+      endif()
+      list(APPEND cuda_arch_ptx ${arch_ptx})
+    endif()
+  endforeach()
+
+  # remove dots and convert to lists
+  string(REGEX REPLACE "\\." "" cuda_arch_bin "${cuda_arch_bin}")
+  string(REGEX REPLACE "\\." "" cuda_arch_ptx "${cuda_arch_ptx}")
+  string(REGEX MATCHALL "[0-9()]+a?" cuda_arch_bin "${cuda_arch_bin}")
+  string(REGEX MATCHALL "[0-9]+a?"   cuda_arch_ptx "${cuda_arch_ptx}")
+
+  if(cuda_arch_bin)
+    list(REMOVE_DUPLICATES cuda_arch_bin)
+  endif()
+  if(cuda_arch_ptx)
+    list(REMOVE_DUPLICATES cuda_arch_ptx)
+  endif()
+
+  set(nvcc_flags "")
+  set(nvcc_archs_readable "")
+
+  # Tell NVCC to add binaries for the specified GPUs
+  foreach(arch ${cuda_arch_bin})
+    if(arch MATCHES "([0-9]+)\\(([0-9]+)\\)")
+      # User explicitly specified ARCH for the concrete CODE
+      list(APPEND nvcc_flags -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1})
+      list(APPEND nvcc_archs_readable sm_${CMAKE_MATCH_1})
+    else()
+      # User didn't explicitly specify ARCH for the concrete CODE, we assume ARCH=CODE
+      list(APPEND nvcc_flags -gencode arch=compute_${arch},code=sm_${arch})
+      list(APPEND nvcc_archs_readable sm_${arch})
+    endif()
+  endforeach()
+
+  # Tell NVCC to add PTX intermediate code for the specified architectures
+  foreach(arch ${cuda_arch_ptx})
+    list(APPEND nvcc_flags -gencode arch=compute_${arch},code=compute_${arch})
+    list(APPEND nvcc_archs_readable compute_${arch})
+  endforeach()
+
+  string(REPLACE ";" " " nvcc_archs_readable "${nvcc_archs_readable}")
+  set(${out_variable}          ${nvcc_flags}          PARENT_SCOPE)
+  set(${out_variable}_readable ${nvcc_archs_readable} PARENT_SCOPE)
+endfunction()

parrot/lib/python3.10/site-packages/torch/share/cmake/Caffe2/public/xpu.cmake

@@ -0,0 +1,30 @@
+# ---[ xpu
+
+# Poor man's include guard
+if(TARGET torch::xpurt)
+  return()
+endif()
+
+# Find SYCL library.
+find_package(SYCLToolkit REQUIRED)
+if(NOT SYCL_FOUND)
+  set(PYTORCH_FOUND_XPU FALSE)
+  return()
+endif()
+set(PYTORCH_FOUND_XPU TRUE)
+
+# SYCL library interface
+add_library(torch::sycl INTERFACE IMPORTED)
+
+set_property(
+    TARGET torch::sycl PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+    ${SYCL_INCLUDE_DIR})
+set_property(
+    TARGET torch::sycl PROPERTY INTERFACE_LINK_LIBRARIES
+    ${SYCL_LIBRARY})
+
+# xpurt
+add_library(torch::xpurt INTERFACE IMPORTED)
+set_property(
+    TARGET torch::xpurt PROPERTY INTERFACE_LINK_LIBRARIES
+    torch::sycl)

videochat2/lib/python3.10/site-packages/tensorflow/python/_pywrap_toco_api.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9afb8654cb0473a45215f50e88d2deb315a9502f97ffbe579e944f69d21af3f
+size 207656

videochat2/lib/python3.10/site-packages/tensorflow/python/layers/base.py

@@ -0,0 +1,22 @@
+# 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.
+# =============================================================================
+"""Contains the base Layer class, from which all layers inherit."""
+from tensorflow.python.keras.legacy_tf_layers import base
+
+InputSpec = base.InputSpec
+
+keras_style_scope = base.keras_style_scope
+set_keras_style = base.set_keras_style
+Layer = base.Layer

videochat2/lib/python3.10/site-packages/tensorflow/python/layers/convolutional.py

@@ -0,0 +1,48 @@
+# 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.
+# =============================================================================
+
+"""Contains the convolutional layer classes and their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import convolutional
+
+Conv1D = convolutional.Conv1D
+conv1d = convolutional.conv1d
+Conv2D = convolutional.Conv2D
+conv2d = convolutional.conv2d
+Conv3D = convolutional.Conv3D
+conv3d = convolutional.conv3d
+SeparableConv1D = convolutional.SeparableConv1D
+SeparableConv2D = convolutional.SeparableConv2D
+separable_conv1d = convolutional.separable_conv1d
+separable_conv2d = convolutional.separable_conv2d
+Conv2DTranspose = convolutional.Conv2DTranspose
+conv2d_transpose = convolutional.conv2d_transpose
+Conv3DTranspose = convolutional.Conv3DTranspose
+conv3d_transpose = convolutional.conv3d_transpose
+
+# Aliases
+
+Convolution1D = Conv1D
+Convolution2D = Conv2D
+Convolution3D = Conv3D
+SeparableConvolution2D = SeparableConv2D
+Convolution2DTranspose = Deconvolution2D = Deconv2D = Conv2DTranspose
+Convolution3DTranspose = Deconvolution3D = Deconv3D = Conv3DTranspose
+convolution1d = conv1d
+convolution2d = conv2d
+convolution3d = conv3d
+separable_convolution2d = separable_conv2d
+convolution2d_transpose = deconvolution2d = deconv2d = conv2d_transpose
+convolution3d_transpose = deconvolution3d = deconv3d = conv3d_transpose

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

@@ -0,0 +1,33 @@
+# 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.
+# =============================================================================
+
+"""Contains the core layers: Dense, Dropout.
+
+Also contains their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import core
+
+
+Dense = core.Dense
+dense = core.dense
+Dropout = core.Dropout
+dropout = core.dropout
+Flatten = core.Flatten
+flatten = core.flatten
+
+# Aliases
+
+FullyConnected = Dense
+fully_connected = dense

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

@@ -0,0 +1,71 @@
+# 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=line-too-long
+"""This library provides a set of high-level neural networks layers."""
+
+# pylint: disable=g-bad-import-order,unused-import
+
+# Base objects.
+from tensorflow.python.layers.base import Layer
+
+# Core layers.
+from tensorflow.python.layers.core import Dense
+from tensorflow.python.layers.core import Dropout
+from tensorflow.python.layers.core import Flatten
+
+from tensorflow.python.layers.core import dense
+from tensorflow.python.layers.core import dropout
+from tensorflow.python.layers.core import flatten
+
+# Convolutional layers.
+from tensorflow.python.layers.convolutional import SeparableConv1D
+from tensorflow.python.layers.convolutional import SeparableConv2D
+from tensorflow.python.layers.convolutional import SeparableConvolution2D
+from tensorflow.python.layers.convolutional import Conv2DTranspose
+from tensorflow.python.layers.convolutional import Convolution2DTranspose
+from tensorflow.python.layers.convolutional import Conv3DTranspose
+from tensorflow.python.layers.convolutional import Convolution3DTranspose
+from tensorflow.python.layers.convolutional import Conv1D
+from tensorflow.python.layers.convolutional import Convolution1D
+from tensorflow.python.layers.convolutional import Conv2D
+from tensorflow.python.layers.convolutional import Convolution2D
+from tensorflow.python.layers.convolutional import Conv3D
+from tensorflow.python.layers.convolutional import Convolution3D
+
+from tensorflow.python.layers.convolutional import separable_conv1d
+from tensorflow.python.layers.convolutional import separable_conv2d
+from tensorflow.python.layers.convolutional import conv2d_transpose
+from tensorflow.python.layers.convolutional import conv3d_transpose
+from tensorflow.python.layers.convolutional import conv1d
+from tensorflow.python.layers.convolutional import conv2d
+from tensorflow.python.layers.convolutional import conv3d
+
+# Pooling layers.
+from tensorflow.python.layers.pooling import AveragePooling1D
+from tensorflow.python.layers.pooling import MaxPooling1D
+from tensorflow.python.layers.pooling import AveragePooling2D
+from tensorflow.python.layers.pooling import MaxPooling2D
+from tensorflow.python.layers.pooling import AveragePooling3D
+from tensorflow.python.layers.pooling import MaxPooling3D
+
+from tensorflow.python.layers.pooling import average_pooling1d
+from tensorflow.python.layers.pooling import max_pooling1d
+from tensorflow.python.layers.pooling import average_pooling2d
+from tensorflow.python.layers.pooling import max_pooling2d
+from tensorflow.python.layers.pooling import average_pooling3d
+from tensorflow.python.layers.pooling import max_pooling3d
+
+# pylint: enable=g-bad-import-order,unused-import

videochat2/lib/python3.10/site-packages/tensorflow/python/layers/normalization.py

@@ -0,0 +1,34 @@
+# 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.
+# =============================================================================
+
+"""Contains the normalization layer classes and their functional aliases.
+"""
+
+from tensorflow.python.util import lazy_loader
+
+normalization = lazy_loader.LazyLoader(
+    'normalization', globals(),
+    'tf_keras.legacy_tf_layers.normalization')
+
+
+# pylint: disable=invalid-name
+# lazy load all the attributes until they are accessed for the first time
+def __getattr__(name):
+  if name in ['BatchNormalization', 'BatchNorm']:
+    return normalization.BatchNormalization
+  elif name in ['batch_normalization', 'batch_norm']:
+    return normalization.batch_normalization
+  else:
+    raise AttributeError(f'module {__name__} doesn\'t have attribute {name}')

videochat2/lib/python3.10/site-packages/tensorflow/python/layers/pooling.py

@@ -0,0 +1,39 @@
+# 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.
+# =============================================================================
+
+"""Contains the pooling layer classes and their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import pooling
+
+
+AveragePooling1D = pooling.AveragePooling1D
+average_pooling1d = pooling.average_pooling1d
+MaxPooling1D = pooling.MaxPooling1D
+max_pooling1d = pooling.max_pooling1d
+AveragePooling2D = pooling.AveragePooling2D
+average_pooling2d = pooling.average_pooling2d
+MaxPooling2D = pooling.MaxPooling2D
+max_pooling2d = pooling.max_pooling2d
+AveragePooling3D = pooling.AveragePooling3D
+average_pooling3d = pooling.average_pooling3d
+MaxPooling3D = pooling.MaxPooling3D
+max_pooling3d = pooling.max_pooling3d
+
+# Aliases
+
+AvgPool2D = AveragePooling2D
+MaxPool2D = MaxPooling2D
+max_pool2d = max_pooling2d
+avg_pool2d = average_pooling2d

videochat2/lib/python3.10/site-packages/tensorflow/python/layers/utils.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.
+# =============================================================================
+
+"""Contains layer utilities for input validation and format conversion."""
+from tensorflow.python.framework import smart_cond as smart_module
+from tensorflow.python.ops import cond
+from tensorflow.python.ops import variables
+
+
+def convert_data_format(data_format, ndim):
+  if data_format == 'channels_last':
+    if ndim == 3:
+      return 'NWC'
+    elif ndim == 4:
+      return 'NHWC'
+    elif ndim == 5:
+      return 'NDHWC'
+    else:
+      raise ValueError(f'Input rank: {ndim} not supported. We only support '
+                       'input rank 3, 4 or 5.')
+  elif data_format == 'channels_first':
+    if ndim == 3:
+      return 'NCW'
+    elif ndim == 4:
+      return 'NCHW'
+    elif ndim == 5:
+      return 'NCDHW'
+    else:
+      raise ValueError(f'Input rank: {ndim} not supported. We only support '
+                       'input rank 3, 4 or 5.')
+  else:
+    raise ValueError(f'Invalid data_format: {data_format}. We only support '
+                     '"channels_first" or "channels_last"')
+
+
+def normalize_tuple(value, n, name):
+  """Transforms a single integer or iterable of integers into an integer tuple.
+
+  Args:
+    value: The value to validate and convert. Could an int, or any iterable
+      of ints.
+    n: The size of the tuple to be returned.
+    name: The name of the argument being validated, e.g. "strides" or
+      "kernel_size". This is only used to format error messages.
+
+  Returns:
+    A tuple of n integers.
+
+  Raises:
+    ValueError: If something else than an int/long or iterable thereof was
+      passed.
+  """
+  if isinstance(value, int):
+    return (value,) * n
+  else:
+    try:
+      value_tuple = tuple(value)
+    except TypeError:
+      raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                       f'integers. Received: {str(value)}')
+    if len(value_tuple) != n:
+      raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                       f'integers. Received: {str(value)}')
+    for single_value in value_tuple:
+      try:
+        int(single_value)
+      except (ValueError, TypeError):
+        raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                         f'integers. Received: {str(value)} including element '
+                         f'{str(single_value)} of type '
+                         f'{str(type(single_value))}')
+    return value_tuple
+
+
+def normalize_data_format(value):
+  data_format = value.lower()
+  if data_format not in {'channels_first', 'channels_last'}:
+    raise ValueError('The `data_format` argument must be one of '
+                     '"channels_first", "channels_last". Received: '
+                     f'{str(value)}.')
+  return data_format
+
+
+def normalize_padding(value):
+  padding = value.lower()
+  if padding not in {'valid', 'same'}:
+    raise ValueError('The `padding` argument must be one of "valid", "same". '
+                     f'Received: {str(padding)}.')
+  return padding
+
+
+def conv_output_length(input_length, filter_size, padding, stride, dilation=1):
+  """Determines output length of a convolution given input length.
+
+  Args:
+      input_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+      dilation: dilation rate, integer.
+
+  Returns:
+      The output length (integer).
+  """
+  if input_length is None:
+    return None
+  assert padding in {'same', 'valid', 'full'}
+  dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)
+  if padding == 'same':
+    output_length = input_length
+  elif padding == 'valid':
+    output_length = input_length - dilated_filter_size + 1
+  elif padding == 'full':
+    output_length = input_length + dilated_filter_size - 1
+  return (output_length + stride - 1) // stride
+
+
+def conv_input_length(output_length, filter_size, padding, stride):
+  """Determines input length of a convolution given output length.
+
+  Args:
+      output_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+
+  Returns:
+      The input length (integer).
+  """
+  if output_length is None:
+    return None
+  assert padding in {'same', 'valid', 'full'}
+  if padding == 'same':
+    pad = filter_size // 2
+  elif padding == 'valid':
+    pad = 0
+  elif padding == 'full':
+    pad = filter_size - 1
+  return (output_length - 1) * stride - 2 * pad + filter_size
+
+
+def deconv_output_length(input_length, filter_size, padding, stride):
+  """Determines output length of a transposed convolution given input length.
+
+  Args:
+      input_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+
+  Returns:
+      The output length (integer).
+  """
+  if input_length is None:
+    return None
+  input_length *= stride
+  if padding == 'valid':
+    input_length += max(filter_size - stride, 0)
+  elif padding == 'full':
+    input_length -= (stride + filter_size - 2)
+  return input_length
+
+
+def smart_cond(pred, true_fn=None, false_fn=None, name=None):
+  """Return either `true_fn()` if predicate `pred` is true else `false_fn()`.
+
+  If `pred` is a bool or has a constant value, we return either `true_fn()`
+  or `false_fn()`, otherwise we use `tf.cond` to dynamically route to both.
+
+  Args:
+    pred: A scalar determining whether to return the result of `true_fn` or
+      `false_fn`.
+    true_fn: The callable to be performed if pred is true.
+    false_fn: The callable to be performed if pred is false.
+    name: Optional name prefix when using `tf.cond`.
+
+  Returns:
+    Tensors returned by the call to either `true_fn` or `false_fn`.
+
+  Raises:
+    TypeError: If `true_fn` or `false_fn` is not callable.
+  """
+  if isinstance(pred, variables.Variable):
+    return cond.cond(
+        pred, true_fn=true_fn, false_fn=false_fn, name=name)
+  return smart_module.smart_cond(
+      pred, true_fn=true_fn, false_fn=false_fn, name=name)
+
+
+def constant_value(pred):
+  """Return the bool value for `pred`, or None if `pred` had a dynamic value.
+
+    Args:
+      pred: A scalar, either a Python bool or a TensorFlow boolean variable
+        or tensor, or the Python integer 1 or 0.
+
+    Returns:
+      True or False if `pred` has a constant boolean value, None otherwise.
+
+    Raises:
+      TypeError: If `pred` is not a Variable, Tensor or bool, or Python
+        integer 1 or 0.
+    """
+  # Allow integer booleans.
+  if isinstance(pred, int):
+    if pred == 1:
+      pred = True
+    elif pred == 0:
+      pred = False
+
+  if isinstance(pred, variables.Variable):
+    return None
+  return smart_module.smart_constant_value(pred)

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/__init__.py

@@ -0,0 +1,19 @@
+# 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.
+# =============================================================================
+
+"""Ops related to Tensor Processing Units."""
+
+import os
+os.environ['TPU_ML_PLATFORM'] = 'Tensorflow'

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/api.py

@@ -0,0 +1,33 @@
+# 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.
+# =============================================================================
+"""Modules that need to be exported to the API.
+
+List TPU modules that aren't included elsewhere here so that they can be scanned
+for tf_export decorations.
+"""
+
+# pylint: disable=unused-import
+from tensorflow.python.tpu import bfloat16
+from tensorflow.python.tpu import feature_column_v2
+from tensorflow.python.tpu import tpu
+
+from tensorflow.python.tpu import tpu_embedding_for_serving
+from tensorflow.python.tpu import tpu_embedding_v1
+from tensorflow.python.tpu import tpu_embedding_v2
+from tensorflow.python.tpu import tpu_embedding_v2_utils
+from tensorflow.python.tpu import tpu_embedding_v3
+from tensorflow.python.tpu import tpu_hardware_feature
+from tensorflow.python.tpu import tpu_optimizer
+# pylint: enable=unused-import

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/device_assignment.py

@@ -0,0 +1,569 @@
+# 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 of TPU helper functions."""
+
+import enum
+import math
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.tpu.topology import Topology
+from tensorflow.python.util.tf_export import tf_export
+
+
+SINGLE_CORE_ASSIGNMENT = [[[0, 0, 0, 0]]]
+
+
+def _compute_task_and_cores_to_replicas(core_assignment, topology):
+  """Computes a nested dict which maps task and logical core to replicas."""
+  task_and_cores_to_replicas = {}
+  for replica in range(core_assignment.shape[0]):
+    for logical_core in range(core_assignment.shape[1]):
+      coordinates = core_assignment[replica, logical_core, :]
+      task_id = topology.task_ordinal_at_coordinates(coordinates)
+      if task_id not in task_and_cores_to_replicas:
+        task_and_cores_to_replicas[task_id] = {}
+      if logical_core not in task_and_cores_to_replicas[task_id]:
+        task_and_cores_to_replicas[task_id][logical_core] = set()
+
+      task_and_cores_to_replicas[task_id][logical_core].add(replica)
+
+  task_to_sorted_replica_id = {}
+
+  for task, core_to_replicas in task_and_cores_to_replicas.items():
+    core_to_sorted_replicas = {}
+    for core, replicas in core_to_replicas.items():
+      core_to_sorted_replicas[core] = sorted(replicas)
+
+    task_to_sorted_replica_id[task] = core_to_sorted_replicas
+  return task_to_sorted_replica_id
+
+
+@tf_export("tpu.experimental.DeviceOrderMode")
+class DeviceOrderMode(enum.IntEnum):
+  """The way of determining device orders when computing device assignment."""
+  # By default the mode is set to AUTO, the library will choose to form rings
+  # when that is possible.
+  AUTO = 0
+  # Form rings for replicas and model-parallel cores.
+  RING = 1
+  # Form meshes for replicas and/or model-parallel cores.
+  MESH = 2
+
+
+@tf_export("tpu.experimental.DeviceAssignment")
+class DeviceAssignment(object):
+  """Mapping from logical cores in a computation to the physical TPU topology.
+
+  Prefer to use the `DeviceAssignment.build()` helper to construct a
+  `DeviceAssignment`; it is easier if less flexible than constructing a
+  `DeviceAssignment` directly.
+  """
+
+  def __init__(self, topology: Topology, core_assignment: np.ndarray):
+    """Constructs a `DeviceAssignment` object.
+
+    Args:
+      topology: A `Topology` object that describes the physical TPU topology.
+      core_assignment: A logical to physical core mapping, represented as a
+        rank 3 numpy array. See the description of the `core_assignment`
+        property for more details.
+
+    Raises:
+      ValueError: If `topology` is not `Topology` object.
+      ValueError: If `core_assignment` is not a rank 3 numpy array.
+    """
+    if not isinstance(topology, Topology):
+      raise ValueError("topology must be a Topology object, got {}".format(
+          type(topology)))
+    core_assignment = np.asarray(core_assignment, dtype=np.int32)
+
+    self._topology = topology
+
+    if core_assignment.ndim != 3:
+      raise ValueError("core_assignment must be a rank 3 numpy array, "
+                       f"got shape {core_assignment.shape}")
+
+    self._num_replicas = core_assignment.shape[0]
+    self._num_cores_per_replica = core_assignment.shape[1]
+
+    if core_assignment.shape[-1] != topology.mesh_rank:
+      raise ValueError(
+          "core_assignment.shape[-1] must have size equal to topology "
+          f"rank ({topology.mesh_rank}), got "
+          f"core_assignment.shape={core_assignment.shape}")
+
+    self._core_assignment = core_assignment
+    self._task_and_cores_to_replicas = _compute_task_and_cores_to_replicas(
+        self._core_assignment, topology)
+
+  @property
+  def topology(self) -> Topology:
+    """A `Topology` that describes the TPU topology."""
+    return self._topology
+
+  @property
+  def num_cores_per_replica(self) -> int:
+    """The number of cores per replica."""
+    return self._num_cores_per_replica
+
+  @property
+  def num_replicas(self) -> int:
+    """The number of replicas of the computation."""
+    return self._num_replicas
+
+  @property
+  def core_assignment(self) -> np.ndarray:
+    """The logical to physical core mapping.
+
+    Returns:
+      An integer numpy array of rank 3, with shape
+      `[num_replicas, num_cores_per_replica, topology_rank]`. Maps
+      (replica, logical core) pairs to physical topology coordinates.
+    """
+    return self._core_assignment
+
+  def coordinates(self, replica: int, logical_core: int) -> Tuple:  # pylint:disable=g-bare-generic
+    """Returns the physical topology coordinates of a logical core."""
+    return tuple(self.core_assignment[replica, logical_core, :])
+
+  def lookup_replicas(self, task_id: int, logical_core: int) -> List[int]:
+    """Lookup replica ids by task number and logical core.
+
+    Args:
+      task_id: TensorFlow task number.
+      logical_core: An integer, identifying a logical core.
+    Returns:
+      A sorted list of the replicas that are attached to that task and
+      logical_core.
+    Raises:
+      ValueError: If no replica exists in the task which contains the logical
+      core.
+    """
+    try:
+      return self._task_and_cores_to_replicas[task_id][logical_core]
+    except KeyError:
+      raise ValueError(
+          "Can not find any replica in task: {} contains logical_core: {} ".
+          format(task_id, logical_core))
+
+  def tpu_ordinal(self, replica: int = 0, logical_core: int = 0) -> int:
+    """Returns the ordinal of the TPU device assigned to a logical core."""
+    coordinates = self.coordinates(replica, logical_core)
+    return self._topology.tpu_device_ordinal_at_coordinates(coordinates)
+
+  def host_device(self,
+                  replica: int = 0,
+                  logical_core: int = 0,
+                  job: Optional[str] = None) -> str:
+    """Returns the CPU device attached to a logical core."""
+    coordinates = self.coordinates(replica, logical_core)
+    return self._topology.cpu_device_name_at_coordinates(coordinates, job=job)
+
+  def tpu_device(self,
+                 replica: int = 0,
+                 logical_core: int = 0,
+                 job: Optional[str] = None) -> str:
+    """Returns the name of the TPU device assigned to a logical core."""
+    coordinates = self.coordinates(replica, logical_core)
+    return self._topology.tpu_device_name_at_coordinates(coordinates, job=job)
+
+  @classmethod
+  def build(
+      cls,
+      topology: Topology,
+      computation_shape: Optional[np.ndarray] = None,
+      computation_stride: Optional[np.ndarray] = None,
+      num_replicas: int = 1,
+      device_order_mode: DeviceOrderMode = DeviceOrderMode.AUTO,
+  ) -> "DeviceAssignment":
+    return device_assignment(
+        topology=topology,
+        computation_shape=computation_shape,
+        computation_stride=computation_stride,
+        num_replicas=num_replicas,
+        device_order_mode=device_order_mode,
+    )
+
+
+def _open_ring_2d(x_size: int, y_size: int,
+                  z_coord: int) -> List[Tuple[int, int, int]]:
+  """Ring-order of a X by Y mesh, with a fixed Z coordinate.
+
+  For example, in a 4x4 mesh, this returns the following order.
+    0 -- 1 -- 2 -- 3
+    |    |    |    |
+    15-- 6 -- 5 -- 4
+    |    |    |    |
+    14-- 7 -- 8 -- 9
+    |    |    |    |
+    13-- 12-- 11-- 10
+
+  Note that chip 0 is not included in the output.
+
+  Args:
+    x_size: An integer represents the mesh size in the x-dimension. Must be
+      larger than 1.
+    y_size: An integer represents the mesh size in the y-dimension. Must be
+      larger than 1.
+    z_coord: An integer represents the z-coordinate to use for the chips in the
+      ring.
+
+  Returns:
+    A list of (x,y,z) triples in ring order.
+  """
+  ret = []
+  for i in range(y_size // 2):
+    for j in range(1, x_size):
+      ret.append((j, 2 * i, z_coord))
+    for j in range(x_size - 1, 0, -1):
+      ret.append((j, 2 * i + 1, z_coord))
+  for i in range(y_size - 1, 0, -1):
+    ret.append((0, i, z_coord))
+  return ret
+
+
+def _ring_3d(x_size: int, y_size: int,
+             z_size: int) -> List[Tuple[int, int, int]]:
+  """Ring-order of a X by Y by Z mesh.
+
+  Constructs the 3d ring from 2d rings that are stacked in the Z dimension and
+  joined in one corner.
+
+  z == 0:
+    0 -- 1 -- 2 -- 3
+    |    |    |    |
+    15 - 6 -- 5 -- 4
+    |    |    |    |
+    14 - 7 -- 8 -- 9
+    |    |    |    |
+    13 - 12 - 11 - 10
+  z == 1:
+    63 - 30 - 29 - 28
+    |    |    |    |
+    16 - 25 - 26 - 27
+    |    |    |    |
+    17 - 24 - 23 - 22
+    |    |    |    |
+    18 - 19 - 20 - 21
+  z == 2:
+    62 - 31 - 32 - 33
+    |    |    |    |
+    45 - 36 - 35 - 34
+    |    |    |    |
+    44 - 37 - 38 - 39
+    |    |    |    |
+    43 - 42 - 41 - 40
+  z == 3:
+    61 - 60 - 59 - 58
+    |    |    |    |
+    46 - 55 - 56 - 57
+    |    |    |    |
+    47 - 54 - 53 - 52
+    |    |    |    |
+    48 - 49 - 50 - 51
+
+  Args:
+    x_size: An integer represents the mesh size in the x-dimension. Must be
+      larger than 1.
+    y_size: An integer represents the mesh size in the y-dimension. Must be
+      larger than 1.
+    z_size: An integer represents the mesh size in the z-dimension. Must be
+      larger than 1.  For example, in a 4x4x4 mesh, this returns the following
+      order.
+
+  Returns:
+    A list of (x,y,z) triples in ring order.
+  """
+
+  # Handle the case where 2 dimensions are size 1.
+  if x_size == 1 and y_size == 1:
+    return [(0, 0, i) for i in range(z_size)]
+  if x_size == 1 and z_size == 1:
+    return [(0, i, 0) for i in range(y_size)]
+  if y_size == 1 and z_size == 1:
+    return [(i, 0, 0) for i in range(x_size)]
+
+  # Handle odd mesh dimensions.  This never happens in practice, so we don't
+  # bother to try building something optimal.
+  if (x_size > 1 and x_size % 2 != 0) or (y_size > 1 and
+                                          y_size % 2 != 0) or (z_size > 1 and
+                                                               z_size % 2 != 0):
+    logging.warning("Odd dimension")
+    ret = []
+    for z in range(z_size):
+      for y in range(y_size):
+        ret.extend((x, y, z) for x in range(x_size))
+    return ret
+
+  # Always start with chip 0.
+  ret = [(0, 0, 0)]
+  # Handle the case where one dimension is size 1.  We just build a flat, 2d
+  # ring.
+  if z_size == 1:
+    ret.extend(_open_ring_2d(x_size, y_size, 0))
+    return ret
+  if y_size == 1:
+    ret = [(0, 0, 0)]
+    ret.extend((x, y, z) for (x, z, y) in _open_ring_2d(x_size, z_size, 0))
+    return ret
+  if x_size == 1:
+    ret = [(0, 0, 0)]
+    ret.extend((x, y, z) for (y, z, x) in _open_ring_2d(y_size, z_size, 0))
+    return ret
+
+  # Handle the case where all dimensions have size > 1 and even.
+  ret = [(0, 0, 0)]
+  for i in range(0, z_size):
+    r = _open_ring_2d(x_size, y_size, i)
+    if i % 2 == 0:
+      ret.extend(r)
+    else:
+      ret.extend(reversed(r))
+  for i in range(z_size - 1, 0, -1):
+    ret.append((0, 0, i))
+  return ret
+
+
+def device_assignment(
+    topology: Topology,
+    computation_shape: Optional[np.ndarray] = None,
+    computation_stride: Optional[np.ndarray] = None,
+    num_replicas: int = 1,
+    device_order_mode: DeviceOrderMode = DeviceOrderMode.AUTO,
+) -> DeviceAssignment:
+  """Computes a device_assignment of a computation across a TPU topology.
+
+  Attempts to choose a compact grid of cores for locality.
+
+  Returns a `DeviceAssignment` that describes the cores in the topology assigned
+  to each core of each replica.
+
+  `computation_shape` and `computation_stride` values should be powers of 2 for
+  optimal packing.
+
+  Args:
+    topology: A `Topology` object that describes the TPU cluster topology. To
+      obtain a TPU topology, evaluate the `Tensor` returned by
+      `initialize_system` using `Session.run`. Either a serialized
+      `TopologyProto` or a `Topology` object may be passed. Note: you must
+        evaluate the `Tensor` first; you cannot pass an unevaluated `Tensor`
+        here.
+    computation_shape: A rank 1 int32 numpy array with size equal to the
+      topology rank, describing the shape of the computation's block of cores.
+      If None, the `computation_shape` is `[1] * topology_rank`.
+    computation_stride: A rank 1 int32 numpy array of size `topology_rank`,
+      describing the inter-core spacing of the `computation_shape` cores in the
+      TPU topology. If None, the `computation_stride` is `[1] * topology_rank`.
+    num_replicas: The number of computation replicas to run. The replicas will
+      be packed into the free spaces of the topology.
+    device_order_mode: An enum of `DeviceOrderMode` class which indicates
+      whether to assign devices to form rings or meshes, or let the library to
+      choose.
+
+  Returns:
+    A DeviceAssignment object, which describes the mapping between the logical
+    cores in each computation replica and the physical cores in the TPU
+    topology.
+
+  Raises:
+    ValueError: If `topology` is not a valid `Topology` object.
+    ValueError: If `computation_shape` or `computation_stride` are not 1D int32
+      numpy arrays with shape [3] where all values are positive.
+    ValueError: If computation's replicas cannot fit into the TPU topology.
+  """
+  # Deserialize the Topology proto, if it is a string.
+  if isinstance(topology, bytes):
+    topology = Topology(serialized=topology)
+
+  if not isinstance(topology, Topology):
+    raise ValueError(
+        f"`topology` is not a Topology object; got {type(topology)}")
+
+  topology_rank = len(topology.mesh_shape)
+  mesh_shape = topology.mesh_shape
+  if computation_shape is None:
+    computation_shape = np.array([1] * topology_rank, dtype=np.int32)
+  else:
+    computation_shape = np.asarray(computation_shape, dtype=np.int32)
+
+  if computation_stride is None:
+    computation_stride = np.array([1] * topology_rank, dtype=np.int32)
+  else:
+    computation_stride = np.asarray(computation_stride, dtype=np.int32)
+
+  if computation_shape.shape != (topology_rank,):
+    raise ValueError(
+        f"computation_shape must have shape [{topology_rank}]; "
+        f"got {computation_shape.shape}"
+    )
+  if computation_stride.shape != (topology_rank,):
+    raise ValueError(
+        f"computation_stride must have shape [{topology_rank}]; "
+        f"got {computation_stride.shape}"
+    )
+
+  if any(computation_shape < 1):
+    raise ValueError(
+        "computation_shape must be positive; got computation_shape={}".format(
+            computation_shape))
+  if any(computation_stride < 1):
+    raise ValueError(
+        "computation_stride must be positive; got computation_stride={}".format(
+            computation_stride))
+
+  # Computes the physical size of one computation instance.
+  computation_footprint = computation_shape * computation_stride
+  if any(computation_footprint > mesh_shape):
+    raise ValueError(
+        "computation footprint {} does not fit in TPU topology shape {}".format(
+            computation_footprint, mesh_shape))
+
+  # Computes how many copies of the computation footprint fit in the mesh.
+  block_counts = mesh_shape // computation_footprint
+
+  replica_counts = block_counts * computation_stride
+  max_replicas = np.prod(replica_counts)
+  if num_replicas > max_replicas:
+    raise ValueError(
+        "requested {} replicas but only {} replicas with shape {} and "
+        "computation_stride {} fit in a TPU mesh of shape {}".format(
+            num_replicas, max_replicas, computation_shape, computation_stride,
+            mesh_shape))
+
+  def ceil_of_ratio(n, m):
+    return (n + m - 1) // m
+
+  if topology.missing_devices.size == 0:
+    replica_shape = [0] * topology_rank
+    if num_replicas > 0:
+      remaining_replicas = num_replicas
+      remaining_dims = topology_rank
+
+      # Choose dimensions as close to an equal cube as possible,
+      # in order of increasing dimension size. By visiting dimensions
+      # in increasing size, we assign the most constrained dimension
+      # first, so we won't make infeasible choices.
+      #
+      # As a secondary sort order, visit the last dimension (core index) first,
+      # then the other dimensions in increasing order. This means we try to use
+      # both cores on the same chip in preference to two cores on different
+      # chips.  We visit the x dimension first, and the z dimension last, so
+      # that we prefer to arrange adjacent replicas on the same machine when
+      # possible.
+      #
+      # For example, if num_replicas == 4, we prefer to use a replica_shape of
+      # (2,1,1,2) over (1,1,2,2).
+
+      for x, ni in sorted(((x, ((i + 1) % topology_rank))
+                           for (i, x) in enumerate(replica_counts))):
+        i = (ni + topology_rank - 1) % topology_rank
+        target_size = int(math.ceil(remaining_replicas**(1.0 / remaining_dims)))
+        replica_shape[i] = min(target_size, x)
+        remaining_replicas = ceil_of_ratio(remaining_replicas, replica_shape[i])
+        remaining_dims -= 1
+
+      assert remaining_replicas == 1 and remaining_dims == 0
+
+    # Assigns an offset to each replica such that no two replicas overlap.
+    replica_offsets = np.full([num_replicas, topology_rank], -1, dtype=np.int32)
+
+    enable_3d_tiling = (
+        topology_rank == 4 and
+        computation_shape[-1] == mesh_shape[-1]  # Only handle 3D case.
+        and np.prod(computation_stride) == 1  # Ensure no stride.
+        and num_replicas == max_replicas)  # Full replication.
+
+    if device_order_mode != DeviceOrderMode.AUTO:
+      if device_order_mode == DeviceOrderMode.RING and not enable_3d_tiling:
+        raise ValueError(
+            "device_order_mode=DeviceOrderMode.RING is not compatible with the "
+            "3D tiling current topology.  Try setting "
+            "device_order_mode=DeviceOrderMode.AUTO"
+        )
+      enable_3d_tiling = device_order_mode == DeviceOrderMode.RING
+
+    if enable_3d_tiling:
+      assignment = []
+      inner_ring = _ring_3d(computation_shape[0], computation_shape[1],
+                            computation_shape[2])
+      outer_ring = _ring_3d(replica_shape[0], replica_shape[1],
+                            replica_shape[2])
+
+      for replica in range(num_replicas):
+        outer_x, outer_y, outer_z = outer_ring[replica]
+        per_replica_assignment = []
+        for index in range(np.prod(computation_shape)):
+          inner_x, inner_y, inner_z = inner_ring[index // mesh_shape[-1]]
+          px = outer_x * computation_shape[0] + inner_x
+          py = outer_y * computation_shape[1] + inner_y
+          pz = outer_z * computation_shape[2] + inner_z
+          pi = index % mesh_shape[-1]
+          per_replica_assignment.append([px, py, pz, pi])
+        assignment.append(per_replica_assignment)
+    else:
+      for replica in range(num_replicas):
+        # Chooses a replica number in each axis.
+        t = replica
+        pos = []
+        # Visit the core number first.
+        for dim in np.concatenate([[replica_shape[-1]], replica_shape[:-1]]):
+          pos.append(t % dim)
+          t //= dim
+        replica_pos = np.concatenate([pos[1:], [pos[0]]])
+
+        # Determines where that replica starts in each axis.
+        outer = replica_pos // computation_stride
+        inner = replica_pos % computation_stride
+        replica_offsets[replica, :] = outer * computation_footprint + inner
+
+      # Computes a logical core -> physical core mapping for each replica.
+      indices = [
+          np.arange(0, computation_shape[i] * computation_stride[i],
+                    computation_stride[i]) for i in range(topology_rank)
+      ]
+      indices = np.concatenate(
+          [i[..., np.newaxis] for i in np.meshgrid(*indices, indexing="ij")],
+          axis=-1)
+      indices = indices.reshape((-1, topology_rank))
+      assignment = indices + replica_offsets[:, np.newaxis, :]
+  else:
+    # We have a slice with missing chips. We define a simple assignment by
+    # ignoring computation stride. This assignment should enable a consistent
+    # and correct device assignment on degraded slices. It is optimal when
+    # weights are not sharded. But this device assignment may be sub-optimal for
+    # other model parallelism scenarios.
+    assert np.prod(computation_stride) == 1
+    # Next, we check if we have sufficient devices.
+    assert num_replicas * np.prod(
+        computation_shape) <= topology.num_tasks * topology.num_tpus_per_task
+    # Map replicas to physical devices in task order.
+    device_coordinates = topology.device_coordinates
+    assignment = []
+    devices_per_replica = np.prod(computation_shape)
+    for rindex in range(num_replicas):
+      replica_assignment = []
+      for index in range(devices_per_replica):
+        logical_id = rindex * devices_per_replica + index
+        # Pick logical cores in task order
+        task = logical_id // topology.num_tpus_per_task
+        device = logical_id % topology.num_tpus_per_task
+        # Append physical cores to the replica assignment
+        replica_assignment.append(device_coordinates[task, device, :])
+      assignment.append(replica_assignment)
+
+  return DeviceAssignment(topology, core_assignment=assignment)

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/feature_column.py

@@ -0,0 +1,690 @@
+# 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 Feature Column Library."""
+import math
+
+from tensorflow.python.feature_column import feature_column as fc
+from tensorflow.python.feature_column import feature_column_lib as fc_lib
+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 variable_scope
+from tensorflow.python.tpu import tpu
+from tensorflow.python.tpu import tpu_function
+from tensorflow.python.tpu import tpu_replication
+# pylint: disable=protected-access
+
+
+_TPU_FC_TO_SCOPE = '_tpu_feature_column_scope'
+_SUPPORTED_SEQUENCE_COLUMNS = (fc._SequenceCategoricalColumn,
+                               fc_lib.SequenceCategoricalColumn)
+
+
+# For V2 columns, we support anything that inherits from CategoricalColumn
+# other than those in the denylist. User-provided columns that inherit from
+# CategoricalColumn may or may not be compatible; it is up to the user to
+# manage TPU compatibility for custom columns.
+_SUPPORTED_CATEGORICAL_COLUMNS_V2 = (fc_lib.CategoricalColumn,)
+_DENYLISTED_CATEGORICAL_COLUMNS_V2 = (fc_lib.HashedCategoricalColumn,
+                                      fc_lib.BucketizedColumn,
+                                      fc_lib.CrossedColumn)
+_SUPPORTED_CATEGORICAL_COLUMNS = (fc._IdentityCategoricalColumn,
+                                  fc._VocabularyFileCategoricalColumn,
+                                  fc._VocabularyListCategoricalColumn,
+                                  fc._WeightedCategoricalColumn,
+                                  fc._SequenceCategoricalColumn
+                                 ) + _SUPPORTED_CATEGORICAL_COLUMNS_V2
+_SEQUENCE_FEATURE_LENGTH_POSTFIX = '_seq_length_'
+
+
+def embedding_column(categorical_column,
+                     dimension,
+                     combiner='mean',
+                     initializer=None,
+                     max_sequence_length=0,
+                     learning_rate_fn=None,
+                     use_safe_embedding_lookup=True):
+  """TPU embedding_column for `tf.feature_column.embedding_column`.
+
+  Note that the interface for TPU embedding_column is different from the non-TPU
+  version. The following args available for the non-TPU version are NOT
+  supported: ckpt_to_load_from, tensor_name_in_ckp, max_norm and trainable.
+
+  Args:
+    categorical_column: A categorical_column returned from
+        categorical_column_with_identity, weighted_categorical_column,
+        categorical_column_with_vocabulary_file,
+        categorical_column_with_vocabulary_list,
+        sequence_categorical_column_with_identity,
+        sequence_categorical_column_with_vocabulary_file,
+        sequence_categorical_column_with_vocabulary_list
+    dimension: An integer specifying dimension of the embedding, must be > 0.
+    combiner: A string specifying how to reduce if there are multiple entries
+      in a single row for a non-sequence column. For more information, see
+      `tf.feature_column.embedding_column`.
+    initializer: A variable initializer function to be used in embedding
+      variable initialization. If not specified, defaults to
+      `tf.compat.v1.truncated_normal_initializer` with mean `0.0` and
+      standard deviation `1/sqrt(dimension)`.
+    max_sequence_length: An non-negative integer specifying the max sequence
+      length. Any sequence shorter then this will be padded with 0 embeddings
+      and any sequence longer will be truncated. This must be positive for
+      sequence features and 0 for non-sequence features.
+    learning_rate_fn: A function that takes global step and returns learning
+      rate for the embedding table. If you intend to use the same learning rate
+      for multiple embedding tables, please ensure that you pass the exact same
+      python function to all calls of embedding_column, otherwise performence
+      may suffer.
+    use_safe_embedding_lookup: If true, uses safe_embedding_lookup_sparse
+      instead of embedding_lookup_sparse. safe_embedding_lookup_sparse ensures
+      there are no empty rows and all weights and ids are positive at the
+      expense of extra compute cost. This only applies to rank 2 (NxM) shaped
+      input tensors. Defaults to true, consider turning off if the above checks
+      are not needed. Note that having empty rows will not trigger any error
+      though the output result might be 0 or omitted.
+
+  Returns:
+    A  _TPUEmbeddingColumn.
+
+  Raises:
+    ValueError: if `dimension` not > 0.
+    ValueError: if `initializer` is specified but not callable.
+    TypeError: if categorical_column is not a supported type.
+  """
+  if isinstance(categorical_column, _DENYLISTED_CATEGORICAL_COLUMNS_V2):
+    raise TypeError('categorical_column for tpu '
+                    ' embedding_column was '
+                    f'denylisted type {type(categorical_column)}')
+  if not isinstance(categorical_column, _SUPPORTED_CATEGORICAL_COLUMNS):
+    raise TypeError(
+        'categorical_column for tpu '
+        ' embedding_column must be type {}, got {}.'.format(' or '.join([
+            cc.__name__ for cc in _SUPPORTED_CATEGORICAL_COLUMNS
+        ]), type(categorical_column)))
+  if (dimension is None) or (dimension < 1):
+    raise ValueError('Invalid dimension {}.'.format(dimension))
+
+  if (initializer is not None) and (not callable(initializer)):
+    raise ValueError('initializer must be callable if specified. '
+                     'Embedding of column_name: {}'.format(
+                         categorical_column.name))
+  if initializer is None:
+    initializer = init_ops.truncated_normal_initializer(
+        mean=0.0, stddev=1 / math.sqrt(dimension))
+
+  embedding_shape = categorical_column._num_buckets, dimension  # pylint: disable=protected-access
+
+  def _creator(weight_collections, scope):
+    embedding_column_layer = fc._EmbeddingColumnLayer(
+        embedding_shape=embedding_shape,
+        initializer=initializer,
+        weight_collections=weight_collections,
+        trainable=True,
+        name='embedding_column_layer')
+    return embedding_column_layer(None, scope=scope)  # pylint: disable=not-callable
+
+  column = _TPUEmbeddingColumn(
+      categorical_column=categorical_column,
+      dimension=dimension,
+      combiner=combiner,
+      layer_creator=_creator,
+      ckpt_to_load_from=None,
+      tensor_name_in_ckpt=None,
+      max_norm=None,
+      trainable=True,
+      max_sequence_length=max_sequence_length,
+      learning_rate_fn=learning_rate_fn,
+      use_safe_embedding_lookup=use_safe_embedding_lookup)
+  # For Embedding column, the initializer is hidden inside the creator Fn, which
+  # is not accessible later. So, we attach it to a special field. Also note
+  # that non-TPU Embedding column and non-TPU shared Embedding column handle the
+  # initializer differently. See shared_embedding_columns for details.
+  column._tpu_initializer = initializer
+  return column
+
+
+def shared_embedding_columns(categorical_columns,
+                             dimension,
+                             combiner='mean',
+                             initializer=None,
+                             shared_embedding_collection_name=None,
+                             max_sequence_lengths=None,
+                             learning_rate_fn=None,
+                             use_safe_embedding_lookup=True):
+  """List of dense columns that convert from sparse, categorical input.
+
+  Note that the interface for TPU embedding_column is different from the non-TPU
+  version. The following args available for the non-TPU version are NOT
+  supported: ckpt_to_load_from, tensor_name_in_ckp, max_norm and trainable.
+
+  Args:
+    categorical_columns: A list of categorical_columns returned from
+        categorical_column_with_identity, weighted_categorical_column,
+        categorical_column_with_vocabulary_file,
+        categorical_column_with_vocabulary_list,
+        sequence_categorical_column_with_identity,
+        sequence_categorical_column_with_vocabulary_file,
+        sequence_categorical_column_with_vocabulary_list
+    dimension: An integer specifying dimension of the embedding, must be > 0.
+    combiner: A string specifying how to reduce if there are multiple entries
+      in a single row for a non-sequence column. For more information, see
+      `tf.feature_column.embedding_column`.
+    initializer: A variable initializer function to be used in embedding
+      variable initialization. If not specified, defaults to
+      `tf.truncated_normal_initializer` with mean `0.0` and standard deviation
+      `1/sqrt(dimension)`.
+    shared_embedding_collection_name: Optional name of the collection where
+      shared embedding weights are added. If not given, a reasonable name will
+      be chosen based on the names of `categorical_columns`. This is also used
+      in `variable_scope` when creating shared embedding weights.
+    max_sequence_lengths: An list of non-negative integers, either None or
+      empty or the same length as the argument categorical_columns. Entries
+      corresponding to non-sequence columns must be 0 and entries corresponding
+      to sequence columns specify the max sequence length for the column. Any
+      sequence shorter then this will be padded with 0 embeddings and any
+      sequence longer will be truncated.
+    learning_rate_fn: A function that takes global step and returns learning
+      rate for the embedding table. If you intend to use the same learning rate
+      for multiple embedding tables, please ensure that you pass the exact same
+      python function to all calls of shared_embedding_columns, otherwise
+      performence may suffer.
+    use_safe_embedding_lookup: If true, uses safe_embedding_lookup_sparse
+      instead of embedding_lookup_sparse. safe_embedding_lookup_sparse ensures
+      there are no empty rows and all weights and ids are positive at the
+      expense of extra compute cost. This only applies to rank 2 (NxM) shaped
+      input tensors. Defaults to true, consider turning off if the above checks
+      are not needed. Note that having empty rows will not trigger any error
+      though the output result might be 0 or omitted.
+
+  Returns:
+    A  _TPUEmbeddingColumn.
+
+  Raises:
+    ValueError: if `dimension` not > 0.
+    ValueError: if `initializer` is specified but not callable.
+    ValueError: if `max_sequence_lengths` is specified and not the same length
+      as `categorical_columns`.
+    ValueError: if `max_sequence_lengths` is positive for a non sequence column
+      or 0 for a sequence column.
+  """
+  for categorical_column in categorical_columns:
+    if isinstance(categorical_column, _DENYLISTED_CATEGORICAL_COLUMNS_V2):
+      raise TypeError('categorical_column for tpu '
+                      ' embedding_column was denylisted type '
+                      f'{type(categorical_column)}')
+    if not isinstance(categorical_column, _SUPPORTED_CATEGORICAL_COLUMNS):
+      raise TypeError(
+          'categorical_column for tpu '
+          ' shared_embedding_columns must be type {}, got {}.'.format(
+              ' or '.join(
+                  [cc.__name__ for cc in _SUPPORTED_CATEGORICAL_COLUMNS]),
+              type(categorical_column)))
+
+  if not max_sequence_lengths:
+    max_sequence_lengths = [0] * len(categorical_columns)
+  if len(max_sequence_lengths) != len(categorical_columns):
+    raise ValueError('max_sequence_lengths and categorical_columns must be of '
+                     'the same length. len(max_sequence_lengths)={} '
+                     'len(categorical_columns)={}.'.format(
+                         len(max_sequence_lengths), len(categorical_columns)))
+
+  if (dimension is None) or (dimension < 1):
+    raise ValueError('Invalid dimension {}.'.format(dimension))
+
+  if (initializer is not None) and (not callable(initializer)):
+    raise ValueError('initializer must be callable if specified. ')
+  if initializer is None:
+    initializer = init_ops.truncated_normal_initializer(
+        mean=0.0, stddev=1 / math.sqrt(dimension))
+
+  # Sort the columns so the default collection name is deterministic even if the
+  # user passes columns from an unsorted collection, such as dict.values().
+  sorted_columns = sorted(categorical_columns, key=lambda x: x.name)
+  num_buckets = sorted_columns[0]._num_buckets  # pylint: disable=protected-access
+
+  for c in sorted_columns[1:]:
+    if num_buckets != c._num_buckets:  # pylint: disable=protected-access
+      raise ValueError(
+          'To use shared_embedding_column, all categorical_columns must have '
+          'the same number of buckets. Given column: {} with buckets: {} does  '
+          'not match column: {} with buckets: {}'.format(
+              sorted_columns[0], num_buckets, c, c._num_buckets))  # pylint: disable=protected-access
+
+  if not shared_embedding_collection_name:
+    shared_embedding_collection_name = '_'.join(c.name for c in sorted_columns)
+    shared_embedding_collection_name += '_shared_embedding'
+
+  tpu_columns = []
+
+  # Create the state (_SharedEmbeddingColumnLayer) here.
+  for categorical_column, max_sequence_length in zip(
+      categorical_columns, max_sequence_lengths):
+    column = _TPUSharedEmbeddingColumn(
+        categorical_column=categorical_column,
+        dimension=dimension,
+        combiner=combiner,
+        initializer=initializer,
+        shared_embedding_collection_name=shared_embedding_collection_name,
+        ckpt_to_load_from=None,
+        tensor_name_in_ckpt=None,
+        max_norm=None,
+        trainable=True,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+    tpu_columns.append(column)
+
+  return tpu_columns
+
+
+class _TPUBaseEmbeddingColumn(object):
+  """Base class for TPU Embedding Column."""
+
+  def __init__(self,
+               categorical_column,
+               max_sequence_length=0,
+               learning_rate_fn=None):
+    self._tpu_categorical_column = categorical_column
+    self._max_sequence_length = max_sequence_length
+    self._learning_rate_fn = learning_rate_fn
+    if (self.is_sequence_column() and max_sequence_length < 1):
+      raise ValueError('max_sequence_length must be greater than 0 for '
+                       'sequence columns. Got max_sequence_length={} for '
+                       'sequence column {}.'.format(max_sequence_length,
+                                                    categorical_column.name))
+    if (not self.is_sequence_column() and max_sequence_length != 0):
+      raise ValueError('Non zero max_seq_length={} specified for non '
+                       'sequence column {}.'.format(max_sequence_length,
+                                                    categorical_column.name))
+
+  def get_combiner(self):
+    """Returns the embedding combiner."""
+    raise NotImplementedError('not implemented')
+
+  def get_embedding_table_size(self):
+    """Returns the embedding table size, tuple of vocab size and dimension."""
+    raise NotImplementedError('not implemented')
+
+  def get_feature_key_name(self):
+    """Returns the feature key name in the features dict."""
+    raise NotImplementedError('not impl')
+
+  def get_weight_key_name(self):
+    """Return the key name for weights."""
+    raise NotImplementedError('not impl')
+
+  def get_embedding_var_name(self):
+    """Returns the embedding variable name.
+
+    Feature key name and embedding variable name are usually one-to-one mapping.
+    But for shared embedding columns, it is many-to-one mapping.
+    """
+    raise NotImplementedError('not impl')
+
+  def get_initializer(self):
+    """Returns the initializer."""
+    raise NotImplementedError('not impl')
+
+  def is_categorical_column_weighted(self):
+    """Check if the categorical column of the embedding column is weighted."""
+    raise NotImplementedError('not impl')
+
+  def is_sequence_column(self):
+    return isinstance(self._tpu_categorical_column, _SUPPORTED_SEQUENCE_COLUMNS)
+
+  def get_max_sequence_length(self):
+    return self._max_sequence_length
+
+  def get_learning_rate_fn(self):
+    return self._learning_rate_fn
+
+  def get_sequence_length_feature_key_name(self):
+    """Get the key for the associated sequence length feature."""
+    return get_sequence_length_feature_key_name_from_feature_key_name(
+        self.get_feature_key_name())
+
+
+class _TPUEmbeddingColumn(_TPUBaseEmbeddingColumn, fc._EmbeddingColumn):
+  """Core Embedding Column."""
+
+  def __new__(cls,
+              categorical_column,
+              dimension,
+              combiner='mean',
+              layer_creator=None,
+              ckpt_to_load_from=None,
+              tensor_name_in_ckpt=None,
+              max_norm=None,
+              trainable=True,
+              max_sequence_length=0,
+              learning_rate_fn=None,
+              use_safe_embedding_lookup=True,
+              bypass_scope_validation=False):
+    # Note, args ckpt_to_load_from, tensor_name_in_ckpt, max_norm and trainable
+    # are not supported on TPU. They are solely for matching the signature of
+    # __new__ of parent class fc._EmbeddingColumn.
+    del bypass_scope_validation
+    # pylint: disable=redundant-keyword-arg
+    return fc._EmbeddingColumn.__new__(
+        cls,
+        categorical_column,
+        dimension,
+        combiner=combiner,
+        layer_creator=layer_creator,
+        ckpt_to_load_from=ckpt_to_load_from,
+        tensor_name_in_ckpt=tensor_name_in_ckpt,
+        max_norm=max_norm,
+        trainable=trainable,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+
+  def __init__(self,
+               categorical_column,
+               dimension,
+               combiner='mean',
+               layer_creator=None,
+               ckpt_to_load_from=None,
+               tensor_name_in_ckpt=None,
+               max_norm=None,
+               trainable=True,
+               max_sequence_length=0,
+               learning_rate_fn=None,
+               use_safe_embedding_lookup=True,
+               bypass_scope_validation=False):
+    _TPUBaseEmbeddingColumn.__init__(
+        self,
+        categorical_column,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn)
+    self._key = None
+    # If true, scope validation is skipped to allow the same column to be used
+    # in multiple variable scopes. By default, this is False, and we expect a
+    # 1:1 mapping between feature columns and scopes.
+    self._bypass_scope_validation = bypass_scope_validation
+
+  def get_combiner(self):
+    return self.combiner
+
+  def get_embedding_table_size(self):
+    """Returns num_ids and width."""
+    return (self.categorical_column._num_buckets, self.dimension)
+
+  def get_feature_key_name(self):
+    """get_feature_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.categorical_column.name
+    return self.categorical_column.name
+
+  def get_weight_key_name(self):
+    """get_weight_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.weight_feature_key
+    return None
+
+  def get_embedding_var_name(self):
+    """get_embedding_var_name."""
+    return self.categorical_column.name
+
+  def get_initializer(self):
+    return self._tpu_initializer
+
+  def is_categorical_column_weighted(self):
+    """Check if the categorical column of the embedding column is weighted."""
+    if isinstance(
+        self.categorical_column,
+        (
+            fc._WeightedCategoricalColumn,  # pylint: disable=protected-access
+            fc_lib.WeightedCategoricalColumn)):
+      return True
+    return False
+
+  def _get_dense_tensor(self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc._EmbeddingColumn._get_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc._EmbeddingColumn._get_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    # TPU mode
+    # Get the embeddings from the LazyBuilder.
+    tensor = inputs.get(self.get_feature_key_name())
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        bypass_scope_validation=self._bypass_scope_validation)
+
+    return tensor
+
+  def _get_sequence_dense_tensor(
+      self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc._EmbeddingColumn._get_sequence_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc._EmbeddingColumn._get_sequence_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    tensor = inputs.get(self.get_feature_key_name())
+    tensor_lengths = inputs.get(self.get_sequence_length_feature_key_name())
+
+    # inputs is a _LazyBuilder and for rank 1 tensors, it calls expand_dims(-1).
+    # We need to undo this to match the standard CPU sequence embedding.
+    tensor_lengths = array_ops.squeeze(tensor_lengths, -1)
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        bypass_scope_validation=self._bypass_scope_validation)
+
+    return fc._SequenceDenseColumn.TensorSequenceLengthPair(
+        dense_tensor=tensor, sequence_length=tensor_lengths)
+
+
+class _TPUSharedEmbeddingColumn(_TPUBaseEmbeddingColumn,
+                                fc._SharedEmbeddingColumn):
+  """Core Shared Embedding Column."""
+
+  def __new__(cls,
+              categorical_column,
+              dimension,
+              combiner='mean',
+              initializer=None,
+              shared_embedding_collection_name=None,
+              ckpt_to_load_from=None,
+              tensor_name_in_ckpt=None,
+              max_norm=None,
+              trainable=True,
+              max_sequence_length=0,
+              learning_rate_fn=None,
+              use_safe_embedding_lookup=True):
+    return fc._SharedEmbeddingColumn.__new__(
+        cls,
+        categorical_column,
+        dimension,
+        combiner=combiner,
+        initializer=initializer,
+        shared_embedding_collection_name=shared_embedding_collection_name,
+        ckpt_to_load_from=ckpt_to_load_from,
+        tensor_name_in_ckpt=tensor_name_in_ckpt,
+        max_norm=max_norm,
+        trainable=trainable,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+
+  def __init__(self,
+               categorical_column,
+               dimension,
+               combiner='mean',
+               initializer=None,
+               shared_embedding_collection_name=None,
+               ckpt_to_load_from=None,
+               tensor_name_in_ckpt=None,
+               max_norm=None,
+               trainable=True,
+               max_sequence_length=0,
+               learning_rate_fn=None,
+               use_safe_embedding_lookup=True):
+
+    _TPUBaseEmbeddingColumn.__init__(
+        self,
+        categorical_column,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn)
+    self._key = None
+
+  def get_combiner(self):
+    return self.combiner
+
+  def get_embedding_table_size(self):
+    """Returns num_ids and width."""
+    return (self.categorical_column._num_buckets, self.dimension)
+
+  def get_feature_key_name(self):
+    """get_feature_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.categorical_column.name
+    return self.categorical_column.name
+
+  def get_weight_key_name(self):
+    """get_weight_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.weight_feature_key
+    return None
+
+  def get_embedding_var_name(self):
+    """get_embedding_var_name."""
+    return self.shared_embedding_collection_name
+
+  def get_initializer(self):
+    return self.initializer
+
+  def is_categorical_column_weighted(self):
+    """Check if the categorical column of the embedding column is weighted."""
+    if isinstance(
+        self.categorical_column,
+        (
+            fc._WeightedCategoricalColumn,  # pylint: disable=protected-access
+            fc_lib.WeightedCategoricalColumn)):
+      return True
+    return False
+
+  def _get_dense_tensor(self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc._SharedEmbeddingColumn._get_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc._SharedEmbeddingColumn._get_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    # TPU mode
+    # Get the embeddings from the LazyBuilder.
+    tensor = inputs.get(self.get_feature_key_name())
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        is_shared_embedding=True)
+    return tensor
+
+  def _get_sequence_dense_tensor(
+      self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc._SharedEmbeddingColumn._get_sequence_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc._SharedEmbeddingColumn._get_sequence_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    tensor = inputs.get(self.get_feature_key_name())
+    tensor_lengths = inputs.get(self.get_sequence_length_feature_key_name())
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        is_shared_embedding=True)
+
+    return fc._SequenceDenseColumn.TensorSequenceLengthPair(
+        dense_tensor=tensor, sequence_length=tensor_lengths)
+
+
+def _record_variable_scope_and_name(embedding_var_name,
+                                    embedding_var_name_in_fc,
+                                    is_shared_embedding=False,
+                                    bypass_scope_validation=False):
+  """Add embedding variable name and scope to collection."""
+  g = ops.get_default_graph()
+  collection = g.get_collection_ref(_TPU_FC_TO_SCOPE)
+  if not collection:
+    collection.append({})
+
+  var_def_dict = collection[0]
+
+  captured_scope = variable_scope.get_variable_scope()
+  captured_scope_name = captured_scope.name
+
+  if embedding_var_name in var_def_dict:
+    if (var_def_dict[embedding_var_name][0] != captured_scope_name and
+        not is_shared_embedding and not bypass_scope_validation):
+      raise ValueError(
+          'For embedding var name {}, the variable scope name is different, '
+          'got {}; expected {}'.format(embedding_var_name,
+                                       captured_scope_name,
+                                       var_def_dict[embedding_var_name][0]))
+    if var_def_dict[embedding_var_name][1] != embedding_var_name_in_fc:
+      raise ValueError(
+          'For embedding var name {}, the embedding name is different, '
+          'got {}; expected {}'.format(embedding_var_name,
+                                       embedding_var_name_in_fc,
+                                       var_def_dict[embedding_var_name][1]))
+  else:
+    var_def_dict[embedding_var_name] = (captured_scope_name,
+                                        embedding_var_name_in_fc)
+
+
+def _is_running_on_cpu():
+  """Returns True if the current context is CPU model."""
+  return tpu_function.get_tpu_context().number_of_shards is None
+
+
+def get_sequence_length_feature_key_name_from_feature_key_name(feature_name):
+  """Gets the name of the sequence length feature from that of the base feature.
+
+  Args:
+    feature_name: The feature key of a sequence column.
+
+  Returns:
+    A string which is the feature key for the associated feature length column.
+  """
+  return feature_name + _SEQUENCE_FEATURE_LENGTH_POSTFIX

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/feature_column_v2.py

@@ -0,0 +1,1097 @@
+# 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 Feature Column Library."""
+import copy
+import enum
+import math
+from tensorflow.python.feature_column import feature_column as fc
+from tensorflow.python.feature_column import feature_column_lib as fc_lib
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import embedding_ops
+from tensorflow.python.ops import init_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import sparse_ops
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.tpu import tpu
+from tensorflow.python.tpu import tpu_replication
+from tensorflow.python.tpu.feature_column import _is_running_on_cpu
+from tensorflow.python.tpu.feature_column import _record_variable_scope_and_name
+from tensorflow.python.tpu.feature_column import _SUPPORTED_CATEGORICAL_COLUMNS_V2
+from tensorflow.python.tpu.feature_column import _SUPPORTED_SEQUENCE_COLUMNS
+from tensorflow.python.tpu.feature_column import _TPUBaseEmbeddingColumn
+from tensorflow.python.util.tf_export import tf_export
+# pylint: disable=protected-access
+
+_ALLOWED_DEVICES = ['cpu', 'tpu_tensor_core', 'tpu_embedding_core']
+_TENSOR_CORE_MASK_KEY_SUFFIX = '__TENSOR_CORE_MASK'
+
+
+class EmbeddingDevice(enum.Enum):
+  CPU = 1
+  TPU_TENSOR_CORE = 2
+  TPU_EMBEDDING_CORE = 3
+
+
+@tf_export(v1=['tpu.experimental.embedding_column'])
+def embedding_column_v2(categorical_column,
+                        dimension,
+                        combiner='mean',
+                        initializer=None,
+                        max_sequence_length=0,
+                        learning_rate_fn=None,
+                        embedding_lookup_device=None,
+                        tensor_core_shape=None,
+                        use_safe_embedding_lookup=True):
+  """TPU version of `tf.compat.v1.feature_column.embedding_column`.
+
+  Note that the interface for `tf.tpu.experimental.embedding_column` is
+  different from that of `tf.compat.v1.feature_column.embedding_column`: The
+  following arguments are NOT supported: `ckpt_to_load_from`,
+  `tensor_name_in_ckpt`, `max_norm` and `trainable`.
+
+  Use this function in place of `tf.compat.v1.feature_column.embedding_column`
+  when you want to use the TPU to accelerate your embedding lookups via TPU
+  embeddings.
+
+  ```
+  column = tf.feature_column.categorical_column_with_identity(...)
+  tpu_column = tf.tpu.experimental.embedding_column(column, 10)
+  ...
+  def model_fn(features):
+    dense_feature = tf.keras.layers.DenseFeature(tpu_column)
+    embedded_feature = dense_feature(features)
+    ...
+
+  estimator = tf.estimator.tpu.TPUEstimator(
+      model_fn=model_fn,
+      ...
+      embedding_config_spec=tf.estimator.tpu.experimental.EmbeddingConfigSpec(
+        column=[tpu_column],
+        ...))
+  ```
+
+  Args:
+    categorical_column: A categorical column returned from
+        `categorical_column_with_identity`, `weighted_categorical_column`,
+        `categorical_column_with_vocabulary_file`,
+        `categorical_column_with_vocabulary_list`,
+        `sequence_categorical_column_with_identity`,
+        `sequence_categorical_column_with_vocabulary_file`,
+        `sequence_categorical_column_with_vocabulary_list`
+    dimension: An integer specifying dimension of the embedding, must be > 0.
+    combiner: A string specifying how to reduce if there are multiple entries
+      in a single row for a non-sequence column. For more information, see
+      `tf.feature_column.embedding_column`.
+    initializer: A variable initializer function to be used in embedding
+      variable initialization. If not specified, defaults to
+      `tf.compat.v1.truncated_normal_initializer` with mean `0.0` and
+      standard deviation `1/sqrt(dimension)`.
+    max_sequence_length: An non-negative integer specifying the max sequence
+      length. Any sequence shorter then this will be padded with 0 embeddings
+      and any sequence longer will be truncated. This must be positive for
+      sequence features and 0 for non-sequence features.
+    learning_rate_fn: A function that takes global step and returns learning
+      rate for the embedding table. If you intend to use the same learning rate
+      for multiple embedding tables, please ensure that you pass the exact same
+      python function to all calls of embedding_column, otherwise performence
+      may suffer.
+    embedding_lookup_device: The device on which to run the embedding lookup.
+      Valid options are "cpu", "tpu_tensor_core", and "tpu_embedding_core".
+      If specifying "tpu_tensor_core", a tensor_core_shape must be supplied.
+      If not specified, the default behavior is embedding lookup on
+      "tpu_embedding_core" for training and "cpu" for inference.
+      Valid options for training : ["tpu_embedding_core", "tpu_tensor_core"]
+      Valid options for serving :  ["cpu", "tpu_tensor_core"]
+      For training, tpu_embedding_core is good for large embedding vocab (>1M),
+      otherwise, tpu_tensor_core is often sufficient.
+      For serving, doing embedding lookup on tpu_tensor_core during serving is
+      a way to reduce host cpu usage in cases where that is a bottleneck.
+    tensor_core_shape: If supplied, a list of integers which specifies
+      the intended dense shape to run embedding lookup for this feature on
+      TensorCore. The batch dimension can be left None or -1 to indicate
+      a dynamic shape. Only rank 2 shapes currently supported.
+    use_safe_embedding_lookup: If true, uses safe_embedding_lookup_sparse
+      instead of embedding_lookup_sparse. safe_embedding_lookup_sparse ensures
+      there are no empty rows and all weights and ids are positive at the
+      expense of extra compute cost. This only applies to rank 2 (NxM) shaped
+      input tensors. Defaults to true, consider turning off if the above checks
+      are not needed. Note that having empty rows will not trigger any error
+      though the output result might be 0 or omitted.
+
+  Returns:
+    A  `_TPUEmbeddingColumnV2`.
+
+  Raises:
+    ValueError: if `dimension` not > 0.
+    ValueError: if `initializer` is specified but not callable.
+  """
+
+  if not isinstance(categorical_column, _SUPPORTED_CATEGORICAL_COLUMNS_V2):
+    raise TypeError(
+        'categorical_column for tpu '
+        'embedding_column must be type {}, got {}.'.format(' or '.join([
+            cc.__name__ for cc in _SUPPORTED_CATEGORICAL_COLUMNS_V2
+        ]), type(categorical_column)))
+  if (dimension is None) or (dimension < 1):
+    raise ValueError('Invalid dimension {}.'.format(dimension))
+  if tensor_core_shape and len(tensor_core_shape) != 2:
+    raise ValueError(
+        'tensor_core_shape must be size 2. Got {}.'.format(tensor_core_shape))
+
+  if (initializer is not None) and (not callable(initializer)):
+    raise ValueError('initializer must be callable if specified. '
+                     'Embedding of column_name: {}'.format(
+                         categorical_column.name))
+  if initializer is None:
+    initializer = init_ops.truncated_normal_initializer(
+        mean=0.0, stddev=1 / math.sqrt(dimension))
+
+  if (embedding_lookup_device and
+      embedding_lookup_device not in _ALLOWED_DEVICES):
+    raise ValueError(
+        f'If set, embedding_lookup_device must be in {_ALLOWED_DEVICES}')
+
+  if embedding_lookup_device == 'cpu':
+    embedding_lookup_device = EmbeddingDevice.CPU
+  elif embedding_lookup_device == 'tpu_tensor_core':
+    embedding_lookup_device = EmbeddingDevice.TPU_TENSOR_CORE
+  elif embedding_lookup_device == 'tpu_embedding_core':
+    embedding_lookup_device = EmbeddingDevice.TPU_EMBEDDING_CORE
+
+  if embedding_lookup_device == EmbeddingDevice.TPU_TENSOR_CORE:
+    if not tensor_core_shape:
+      raise ValueError('Using embedding_lookup_device=tpu_tensor_core requires '
+                       'tensor_core_shape to be set.')
+    if isinstance(categorical_column, _SUPPORTED_SEQUENCE_COLUMNS):
+      raise ValueError('embedding_lookup_device=tpu_tensor_core currently does '
+                       'not support sequence columns.')
+
+  if not embedding_lookup_device:
+    return _TPUEmbeddingColumnV2(
+        categorical_column=categorical_column,
+        dimension=dimension,
+        combiner=combiner,
+        initializer=initializer,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+  else:
+    return _TPUDeviceSpecificEmbeddingColumnV2(
+        categorical_column=categorical_column,
+        dimension=dimension,
+        combiner=combiner,
+        initializer=initializer,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn,
+        embedding_lookup_device=embedding_lookup_device,
+        tensor_core_shape=tensor_core_shape,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+
+
+@tf_export(v1=['tpu.experimental.shared_embedding_columns'])
+def shared_embedding_columns_v2(categorical_columns,
+                                dimension,
+                                combiner='mean',
+                                initializer=None,
+                                shared_embedding_collection_name=None,
+                                max_sequence_lengths=None,
+                                learning_rate_fn=None,
+                                embedding_lookup_device=None,
+                                tensor_core_shape=None,
+                                use_safe_embedding_lookup=True):
+  """TPU version of `tf.compat.v1.feature_column.shared_embedding_columns`.
+
+  Note that the interface for `tf.tpu.experimental.shared_embedding_columns` is
+  different from that of `tf.compat.v1.feature_column.shared_embedding_columns`:
+  The following arguments are NOT supported: `ckpt_to_load_from`,
+  `tensor_name_in_ckpt`, `max_norm` and `trainable`.
+
+  Use this function in place of
+  tf.compat.v1.feature_column.shared_embedding_columns` when you want to use the
+  TPU to accelerate your embedding lookups via TPU embeddings.
+
+  ```
+  column_a = tf.feature_column.categorical_column_with_identity(...)
+  column_b = tf.feature_column.categorical_column_with_identity(...)
+  tpu_columns = tf.tpu.experimental.shared_embedding_columns(
+      [column_a, column_b], 10)
+  ...
+  def model_fn(features):
+    dense_feature = tf.keras.layers.DenseFeature(tpu_columns)
+    embedded_feature = dense_feature(features)
+    ...
+
+  estimator = tf.estimator.tpu.TPUEstimator(
+      model_fn=model_fn,
+      ...
+      embedding_config_spec=tf.estimator.tpu.experimental.EmbeddingConfigSpec(
+          column=tpu_columns,
+          ...))
+  ```
+
+  Args:
+    categorical_columns: A list of categorical columns returned from
+      `categorical_column_with_identity`, `weighted_categorical_column`,
+      `categorical_column_with_vocabulary_file`,
+      `categorical_column_with_vocabulary_list`,
+      `sequence_categorical_column_with_identity`,
+      `sequence_categorical_column_with_vocabulary_file`,
+      `sequence_categorical_column_with_vocabulary_list`
+    dimension: An integer specifying dimension of the embedding, must be > 0.
+    combiner: A string specifying how to reduce if there are multiple entries in
+      a single row for a non-sequence column. For more information, see
+      `tf.feature_column.embedding_column`.
+    initializer: A variable initializer function to be used in embedding
+      variable initialization. If not specified, defaults to
+      `tf.truncated_normal_initializer` with mean `0.0` and standard deviation
+      `1/sqrt(dimension)`.
+    shared_embedding_collection_name: Optional name of the collection where
+      shared embedding weights are added. If not given, a reasonable name will
+      be chosen based on the names of `categorical_columns`. This is also used
+      in `variable_scope` when creating shared embedding weights.
+    max_sequence_lengths: An list of non-negative integers, either None or empty
+      or the same length as the argument categorical_columns. Entries
+      corresponding to non-sequence columns must be 0 and entries corresponding
+      to sequence columns specify the max sequence length for the column. Any
+      sequence shorter then this will be padded with 0 embeddings and any
+      sequence longer will be truncated.
+    learning_rate_fn: A function that takes global step and returns learning
+      rate for the embedding table. If you intend to use the same learning rate
+      for multiple embedding tables, please ensure that you pass the exact same
+      python function to all calls of shared_embedding_columns, otherwise
+      performence may suffer.
+    embedding_lookup_device: The device on which to run the embedding lookup.
+      Valid options are "cpu", "tpu_tensor_core", and "tpu_embedding_core". If
+      specifying "tpu_tensor_core", a tensor_core_shape must be supplied.
+      Defaults to "cpu". If not specified, the default behavior is embedding
+      lookup on "tpu_embedding_core" for training and "cpu" for inference.
+      Valid options for training : ["tpu_embedding_core", "tpu_tensor_core"]
+      Valid options for serving :  ["cpu", "tpu_tensor_core"]
+      For training, tpu_embedding_core is good for large embedding vocab (>1M),
+      otherwise, tpu_tensor_core is often sufficient.
+      For serving, doing embedding lookup on tpu_tensor_core during serving is
+      a way to reduce host cpu usage in cases where that is a bottleneck.
+    tensor_core_shape: If supplied, a list of integers which specifies the
+      intended dense shape to run embedding lookup for this feature on
+      TensorCore. The batch dimension can be left None or -1 to indicate a
+      dynamic shape. Only rank 2 shapes currently supported.
+    use_safe_embedding_lookup: If true, uses safe_embedding_lookup_sparse
+      instead of embedding_lookup_sparse. safe_embedding_lookup_sparse ensures
+      there are no empty rows and all weights and ids are positive at the
+      expense of extra compute cost. This only applies to rank 2 (NxM) shaped
+      input tensors. Defaults to true, consider turning off if the above checks
+      are not needed. Note that having empty rows will not trigger any error
+      though the output result might be 0 or omitted.
+
+  Returns:
+    A  list of `_TPUSharedEmbeddingColumnV2`.
+
+  Raises:
+    ValueError: if `dimension` not > 0.
+    ValueError: if `initializer` is specified but not callable.
+    ValueError: if `max_sequence_lengths` is specified and not the same length
+      as `categorical_columns`.
+    ValueError: if `max_sequence_lengths` is positive for a non sequence column
+      or 0 for a sequence column.
+  """
+
+  for categorical_column in categorical_columns:
+    if not isinstance(categorical_column, _SUPPORTED_CATEGORICAL_COLUMNS_V2):
+      raise TypeError(
+          'categorical_column for tpu '
+          ' shared_embedding_columns must be type {}, got {}.'.format(
+              ' or '.join(
+                  [cc.__name__ for cc in _SUPPORTED_CATEGORICAL_COLUMNS_V2]),
+              type(categorical_column)))
+
+  if not max_sequence_lengths:
+    max_sequence_lengths = [0] * len(categorical_columns)
+  if len(max_sequence_lengths) != len(categorical_columns):
+    raise ValueError('max_sequence_lengths and categorical_columns must be of '
+                     'the same length. len(max_sequence_lengths)={} '
+                     'len(categorical_columns)={}.'.format(
+                         len(max_sequence_lengths), len(categorical_columns)))
+
+  if (dimension is None) or (dimension < 1):
+    raise ValueError('Invalid dimension {}.'.format(dimension))
+  if tensor_core_shape and len(tensor_core_shape) != 2:
+    raise ValueError(
+        'tensor_core_shape must be size 2. Got {}.'.format(tensor_core_shape))
+
+  if (initializer is not None) and (not callable(initializer)):
+    raise ValueError('initializer must be callable if specified. ')
+  if initializer is None:
+    initializer = init_ops.truncated_normal_initializer(
+        mean=0.0, stddev=1 / math.sqrt(dimension))
+
+  # Sort the columns so the default collection name is deterministic even if the
+  # user passes columns from an unsorted collection, such as dict.values().
+  sorted_columns = sorted(categorical_columns, key=lambda x: x.name)
+  num_buckets = sorted_columns[0]._num_buckets  # pylint: disable=protected-access
+
+  for c in sorted_columns[1:]:
+    if num_buckets != c._num_buckets:  # pylint: disable=protected-access
+      raise ValueError(
+          'To use shared_embedding_column, all categorical_columns must have '
+          'the same number of buckets. Given column: {} with buckets: {} does  '
+          'not match column: {} with buckets: {}'.format(
+              sorted_columns[0], num_buckets, c, c._num_buckets))  # pylint: disable=protected-access
+
+  if not shared_embedding_collection_name:
+    shared_embedding_collection_name = '_'.join(c.name for c in sorted_columns)
+    shared_embedding_collection_name += '_shared_embedding'
+
+  tpu_columns = []
+
+  column_creator = fc_lib.SharedEmbeddingColumnCreator(
+      dimension=dimension, initializer=initializer, ckpt_to_load_from=None,
+      tensor_name_in_ckpt=None, num_buckets=num_buckets, trainable=None,
+      name=shared_embedding_collection_name)
+
+  if (embedding_lookup_device and
+      embedding_lookup_device not in _ALLOWED_DEVICES):
+    raise ValueError(
+        f'If set, embedding_lookup_device must be in {_ALLOWED_DEVICES}')
+
+  if embedding_lookup_device == 'cpu':
+    embedding_lookup_device = EmbeddingDevice.CPU
+  elif embedding_lookup_device == 'tpu_tensor_core':
+    embedding_lookup_device = EmbeddingDevice.TPU_TENSOR_CORE
+  elif embedding_lookup_device == 'tpu_embedding_core':
+    embedding_lookup_device = EmbeddingDevice.TPU_EMBEDDING_CORE
+
+  if embedding_lookup_device == EmbeddingDevice.TPU_TENSOR_CORE:
+    if not tensor_core_shape:
+      raise ValueError('Using embedding_lookup_device=tpu_tensor_core requires '
+                       'tensor_core_shape to be set.')
+    for c in sorted_columns:
+      if isinstance(c, _SUPPORTED_SEQUENCE_COLUMNS):
+        raise ValueError('embedding_lookup_device=tpu_tensor_core currently '
+                         'does not support sequence columns.')
+
+  # Create the state (_SharedEmbeddingColumnLayer) here.
+  for categorical_column, max_sequence_length in zip(
+      categorical_columns, max_sequence_lengths):
+    if not embedding_lookup_device:
+      column = _TPUSharedEmbeddingColumnV2(
+          categorical_column=categorical_column,
+          shared_embedding_column_creator=column_creator,
+          combiner=combiner,
+          initializer=initializer,
+          shared_embedding_collection_name=shared_embedding_collection_name,
+          max_sequence_length=max_sequence_length,
+          learning_rate_fn=learning_rate_fn,
+          use_safe_embedding_lookup=use_safe_embedding_lookup)
+    else:
+      column = _TPUSharedDeviceSpecificEmbeddingColumnV2(
+          categorical_column=categorical_column,
+          shared_embedding_column_creator=column_creator,
+          combiner=combiner,
+          initializer=initializer,
+          shared_embedding_collection_name=shared_embedding_collection_name,
+          max_sequence_length=max_sequence_length,
+          learning_rate_fn=learning_rate_fn,
+          embedding_lookup_device=embedding_lookup_device,
+          tensor_core_shape=tensor_core_shape,
+          use_safe_embedding_lookup=use_safe_embedding_lookup)
+    tpu_columns.append(column)
+
+  return tpu_columns
+
+
+class _TPUEmbeddingColumnV2(_TPUBaseEmbeddingColumn, fc_lib.EmbeddingColumn):
+  """Core Embedding Column."""
+
+  def __new__(cls,
+              categorical_column,
+              dimension,
+              combiner='mean',
+              initializer=None,
+              max_sequence_length=0,
+              learning_rate_fn=None,
+              use_safe_embedding_lookup=True,
+              bypass_scope_validation=False):
+    del bypass_scope_validation
+    # pylint: disable=redundant-keyword-arg
+    return fc_lib.EmbeddingColumn.__new__(
+        cls,
+        categorical_column,
+        dimension,
+        combiner=combiner,
+        initializer=initializer,
+        ckpt_to_load_from=None,
+        tensor_name_in_ckpt=None,
+        max_norm=None,
+        trainable=True,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+
+  def __getnewargs__(self):
+    return (self._tpu_categorical_column, self.dimension, self.combiner,
+            self.initializer, self._max_sequence_length, self._learning_rate_fn,
+            self.use_safe_embedding_lookup, self._bypass_scope_validation)
+
+  def __deepcopy__(self, memo):
+    return _TPUEmbeddingColumnV2(
+        *(copy.deepcopy(a, memo) for a in self.__getnewargs__()))
+
+  def __init__(self,
+               categorical_column,
+               dimension,
+               combiner='mean',
+               initializer=None,
+               max_sequence_length=0,
+               learning_rate_fn=None,
+               use_safe_embedding_lookup=True,
+               bypass_scope_validation=False):
+    _TPUBaseEmbeddingColumn.__init__(
+        self,
+        categorical_column,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn)
+    self._key = None
+    # If true, scope validation is skipped to allow the same column to be used
+    # in multiple variable scopes. By default, this is False, and we expect a
+    # 1:1 mapping between feature columns and scopes.
+    self._bypass_scope_validation = bypass_scope_validation
+
+  def get_combiner(self):
+    return self.combiner
+
+  def get_embedding_table_size(self):
+    """Returns num_ids and width."""
+    return (self.categorical_column._num_buckets, self.dimension)
+
+  def get_feature_key_name(self):
+    """get_feature_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.categorical_column.name
+    return self.categorical_column.name
+
+  def get_weight_key_name(self):
+    """get_weight_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.weight_feature_key
+    return None
+
+  def get_embedding_var_name(self):
+    """get_embedding_var_name."""
+    return self.categorical_column.name
+
+  def get_initializer(self):
+    return self.initializer
+
+  def is_categorical_column_weighted(self):
+    """Check if the categorical column of the embedding column is weighted."""
+    if isinstance(
+        self.categorical_column,
+        (
+            fc._WeightedCategoricalColumn,  # pylint: disable=protected-access
+            fc_lib.WeightedCategoricalColumn)):
+      return True
+    return False
+
+  def _get_dense_tensor(self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.EmbeddingColumn._get_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.EmbeddingColumn._get_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    # TPU mode
+    # Get the embeddings from the LazyBuilder.
+    tensor = inputs.get(self.get_feature_key_name())
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        bypass_scope_validation=self._bypass_scope_validation)
+
+    return tensor
+
+  def create_state(self, state_manager):
+    if _is_running_on_cpu():
+      return fc_lib.EmbeddingColumn.create_state(
+          self, state_manager)
+
+    # Create state is called for the EmbeddingColumn to create its embedding
+    # variables under feature column V2, if we are on TPU so record the scope
+    # here.
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        bypass_scope_validation=self._bypass_scope_validation)
+
+  def get_dense_tensor(self, transformation_cache, state_manager):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.EmbeddingColumn.get_dense_tensor(
+            self, transformation_cache, state_manager)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.EmbeddingColumn.get_dense_tensor(
+          self, transformation_cache, state_manager)
+
+    # TPU mode
+    # Get the embeddings from the FeatureTransformationCache.
+    tensor = transformation_cache.get(self.get_feature_key_name(),
+                                      state_manager)
+
+    return tensor
+
+  def _get_sequence_dense_tensor(
+      self, inputs, weight_collections=None, trainable=None):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.EmbeddingColumn._get_sequence_dense_tensor(
+            self, inputs, weight_collections, trainable)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.EmbeddingColumn._get_sequence_dense_tensor(
+          self, inputs, weight_collections, trainable)
+
+    tensor = inputs.get(self.get_feature_key_name())
+    tensor_lengths = inputs.get(self.get_sequence_length_feature_key_name())
+
+    # inputs is a _LazyBuilder and for rank 1 tensors, it calls expand_dims(-1).
+    # We need to undo this to match the standard CPU sequence embedding.
+    tensor_lengths = array_ops.squeeze(tensor_lengths, -1)
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        'embedding_weights',
+        bypass_scope_validation=self._bypass_scope_validation)
+
+    return fc_lib.SequenceDenseColumn.TensorSequenceLengthPair(
+        dense_tensor=tensor, sequence_length=tensor_lengths)
+
+  def get_sequence_dense_tensor(self, transformation_cache, state_manager):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.EmbeddingColumn.get_sequence_dense_tensor(
+            self, transformation_cache, state_manager)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.EmbeddingColumn.get_sequence_dense_tensor(
+          self, transformation_cache, state_manager)
+
+    tensor = transformation_cache.get(self.get_feature_key_name(),
+                                      state_manager)
+    tensor_lengths = transformation_cache.get(
+        self.get_sequence_length_feature_key_name(),
+        state_manager)
+
+    # FeatureTransformationCache expands rank 1 tensors (like sequence length)
+    # to rank 2. We need to undo this to match the standard CPU sequence
+    # embedding.
+    tensor_lengths = array_ops.squeeze(tensor_lengths, -1)
+
+    return fc_lib.SequenceDenseColumn.TensorSequenceLengthPair(
+        dense_tensor=tensor, sequence_length=tensor_lengths)
+
+
+class _TPUSharedEmbeddingColumnV2(_TPUBaseEmbeddingColumn,
+                                  fc_lib.SharedEmbeddingColumn):
+  """Core Shared Embedding Column."""
+
+  def __new__(cls,
+              categorical_column,
+              shared_embedding_column_creator,
+              combiner='mean',
+              initializer=None,
+              shared_embedding_collection_name=None,
+              max_sequence_length=0,
+              learning_rate_fn=None,
+              use_safe_embedding_lookup=True):
+    # pylint: disable=redundant-keyword-arg
+    return fc_lib.SharedEmbeddingColumn.__new__(
+        cls,
+        categorical_column,
+        combiner=combiner,
+        shared_embedding_column_creator=shared_embedding_column_creator,
+        max_norm=None,
+        use_safe_embedding_lookup=use_safe_embedding_lookup)
+
+  def __getnewargs__(self):
+    return (self._tpu_categorical_column, self.shared_embedding_column_creator,
+            self.combiner, self._initializer,
+            self._shared_embedding_collection_name, self._max_sequence_length,
+            self._learning_rate_fn)
+
+  def __deepcopy__(self, memo):
+    return _TPUSharedEmbeddingColumnV2(
+        *(copy.deepcopy(a, memo) for a in self.__getnewargs__()))
+
+  def __init__(self,
+               categorical_column,
+               shared_embedding_column_creator,
+               combiner='mean',
+               initializer=None,
+               shared_embedding_collection_name=None,
+               max_sequence_length=0,
+               learning_rate_fn=None,
+               use_safe_embedding_lookup=True):
+
+    _TPUBaseEmbeddingColumn.__init__(
+        self,
+        categorical_column,
+        max_sequence_length=max_sequence_length,
+        learning_rate_fn=learning_rate_fn)
+    self._initializer = initializer
+    self._shared_embedding_collection_name = shared_embedding_collection_name
+
+  def get_combiner(self):
+    return self.combiner
+
+  def get_embedding_table_size(self):
+    """Returns num_ids and width."""
+    return (self.categorical_column._num_buckets,
+            self.shared_embedding_column_creator.dimension)
+
+  def get_feature_key_name(self):
+    """get_feature_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.categorical_column.name
+    return self.categorical_column.name
+
+  def get_weight_key_name(self):
+    """get_weight_key_name."""
+    if self.is_categorical_column_weighted():
+      return self.categorical_column.weight_feature_key
+    return None
+
+  def get_embedding_var_name(self):
+    """get_embedding_var_name."""
+    return self._shared_embedding_collection_name
+
+  def get_initializer(self):
+    return self._initializer
+
+  def is_categorical_column_weighted(self):
+    """Check if the categorical column of the embedding column is weighted."""
+    if isinstance(
+        self.categorical_column,
+        (
+            fc._WeightedCategoricalColumn,  # pylint: disable=protected-access
+            fc_lib.WeightedCategoricalColumn)):
+      return True
+    return False
+
+  def _get_dense_tensor_internal(
+      self, transformation_cache, state_manager):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.SharedEmbeddingColumn._get_dense_tensor_internal(
+            self, transformation_cache, state_manager)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.SharedEmbeddingColumn._get_dense_tensor_internal(
+          self, transformation_cache, state_manager)
+
+    # TPU mode
+    # Get the embeddings from the FeatureTransformationCache.
+    tensor = transformation_cache.get(self.get_feature_key_name(),
+                                      state_manager)
+
+    # Add to collection for _create_tpu_embedding_variables_and_ops
+    # Note that in Feature Column V2, shared embeddings have no scope.
+    _record_variable_scope_and_name(
+        self.get_embedding_var_name(),
+        self.shared_embedding_column_creator._name,
+        is_shared_embedding=True)
+    return tensor
+
+  def get_sequence_dense_tensor(
+      self, transformation_cache, state_manager):
+    if tpu.under_tpu_inference_context():
+      def host_computation():
+        return fc_lib.SharedEmbeddingColumn.get_sequence_dense_tensor(
+            self, transformation_cache, state_manager)
+
+      return tpu_replication.outside_compilation(host_computation)
+
+    if _is_running_on_cpu():
+      return fc_lib.SharedEmbeddingColumn.get_sequence_dense_tensor(
+          self, transformation_cache, state_manager)
+
+    tensor = self._get_dense_tensor_internal(
+        transformation_cache, state_manager)
+    tensor_lengths = transformation_cache.get(
+        self.get_sequence_length_feature_key_name(),
+        state_manager)
+
+    # FeatureTransformationCache expands rank 1 tensors (like sequence length)
+    # to rank 2. We need to undo this to match the standard CPU sequence
+    # embedding.
+    tensor_lengths = array_ops.squeeze(tensor_lengths, -1)
+
+    return fc_lib.SequenceDenseColumn.TensorSequenceLengthPair(
+        dense_tensor=tensor, sequence_length=tensor_lengths)
+
+
+def split_sequence_columns_v2(feature_columns):
+  """Split a list of _TPUEmbeddingColumn into sequence and non-sequence columns.
+
+  For use in a TPUEstimator model_fn function. E.g.
+
+  def model_fn(features):
+    sequence_columns, feature_columns = (
+        tf.tpu.feature_column.split_sequence_columns(feature_columns))
+    input = tf.feature_column.input_layer(
+        features=features, feature_columns=feature_columns)
+    sequence_features, sequence_lengths = (
+        tf.contrib.feature_column.sequence_input_layer(
+            features=features, feature_columns=sequence_columns))
+
+  Args:
+    feature_columns: A list of _TPUEmbeddingColumns to split.
+
+  Returns:
+    Two lists of _TPUEmbeddingColumns, the first is the sequence columns and the
+    second is the non-sequence columns.
+  """
+  sequence_columns = []
+  non_sequence_columns = []
+  for column in feature_columns:
+    if not isinstance(column, (_TPUEmbeddingColumnV2,
+                               _TPUSharedEmbeddingColumnV2)):
+      raise TypeError(
+          'column must be a _TPUEmbeddingColumnV2 or '
+          f'_TPUSharedEmbeddingColumnV2 but got {type(column)} instead.')
+    if column.is_sequence_column():
+      sequence_columns.append(column)
+    else:
+      non_sequence_columns.append(column)
+  return sequence_columns, non_sequence_columns
+
+
+def sparse_embedding_aggregate_slice(params,
+                                     values_and_values_mask,
+                                     combiner='mean',
+                                     name='sparse_embedding_aggregate_slice'):
+  """Uses XLA's dynamic slice operations to perform embedding lookups.
+
+  From third_party/cloud_tpu/models/movielens/tpu_embedding.py
+
+  Args:
+    params: Tensor of embedding table. Rank 2 (table_size x embedding dim)
+    values_and_values_mask: is a two-tuple that contains: values - Tensor of
+      embedding indices. Rank 2 (batch x n_indices) values_mask - Tensor of mask
+      / weights. Rank 2 (batch x n_indices)
+    combiner: The combiner to use for the embedding lookup. Currently supports
+      'sum' and 'mean'.
+    name: Optional name scope for created ops
+
+  Returns:
+    Rank 2 tensor of aggregated (per batch element) embedding vectors.
+
+  Raises:
+    ValueError: Combiner is not supported.
+  """
+  values, values_mask = values_and_values_mask  # unpack the two-tuple
+  with ops.name_scope(name):
+    _, embedding_dimension = params.get_shape().as_list()
+    n_batch, n_indices_padded = values.get_shape().as_list()
+    if not n_batch:
+      n_batch = -1
+
+    emb_lookup = array_ops.reshape(
+        embedding_ops.embedding_lookup(
+            params, array_ops.reshape(values, [n_batch, n_indices_padded])),
+        [n_batch, n_indices_padded, embedding_dimension])
+
+    values_mask_broadcast = array_ops.reshape(values_mask,
+                                              [n_batch, n_indices_padded, 1])
+    aggregate_emb = math_ops.reduce_sum(
+        emb_lookup * values_mask_broadcast, axis=1)
+    if combiner == 'sum':
+      return aggregate_emb
+    elif combiner == 'mean':
+      # In the case we have an empty row, both aggregate_emb and
+      # math_ops.reduce_sum(values_mask_broadcast, axis=1) will be 0. Thus,
+      # we can take max it with a non-zero value to prevent NaNs. Note that
+      # math_ops.reduce_sum(values_mask_broadcast, axis=1) will have integer
+      # values so 1.0 is the smallest value.
+      return aggregate_emb / math_ops.maximum(
+          math_ops.reduce_sum(values_mask_broadcast, axis=1), 1.0)
+    else:
+      raise ValueError('Dense TPU Embedding does not support combiner '
+                       'other than sum and mean.')
+
+
+def pad_sparse_embedding_lookup_indices(sparse_indices, padded_size):
+  """Creates statically-sized Tensors containing indices and weights.
+
+  From third_party/cloud_tpu/models/movielens/tpu_embedding.py
+
+  Also computes sparse_indices.values % embedding_table_size, for equivalent
+  functionality to sparse_column_with_integerized_feature. The returned
+  padded weight Tensor also doubles as a mask indicating which values in
+  the returned padded indices Tensor are indices versus padded zeros.
+
+  Args:
+    sparse_indices: SparseTensor of embedding lookup indices.
+    padded_size: Number of columns of the returned Tensors. Indices which fall
+      out of bounds will be truncated to the padded size.
+
+  Returns:
+    (sparse_indices.values padded to the specified size,
+     a mask the same size as the returned padded values in which 0s
+     indicate padded locations and 1s (or values from sparse_weights)
+     indicate actual values)
+  """
+  batch_size = sparse_indices.dense_shape[0]
+  sparse_indices = sparse_ops.sparse_slice(sparse_indices, [0, 0],
+                                           [batch_size, padded_size])
+  indices, values = sparse_indices.indices, sparse_indices.values
+
+  padded_values = array_ops.scatter_nd(
+      indices,
+      math_ops.cast(values, dtypes.int32),
+      shape=(batch_size, padded_size))
+
+  weights = array_ops.ones_like(values, dtype=dtypes.float32)
+  padded_mask = array_ops.scatter_nd(
+      indices, weights, shape=(batch_size, padded_size))
+
+  return padded_values, padded_mask
+
+
+def _check_invalid_cases(embedding_lookup_device):
+  """Checks for invalid embedding_lookup_device configurations."""
+  if (tpu.under_tpu_inference_context() and
+      embedding_lookup_device == EmbeddingDevice.TPU_EMBEDDING_CORE):
+    raise ValueError(
+        'Using embedding_lookup_device=tpu_embedding_core during inference '
+        'is not supported.')
+  if embedding_lookup_device == EmbeddingDevice.CPU:
+    if not tpu.under_tpu_inference_context():
+      raise ValueError(
+          'Using TPUEmbeddingColumn with embedding_lookup_device="cpu" '
+          'during training is not supported.')
+
+
+class _TPUDeviceSpecificEmbeddingColumnV2(_TPUEmbeddingColumnV2):
+  """TPUEmbeddingColumn which allows serving on TensorCore."""
+
+  def __new__(cls, *args, **kwargs):
+    # For __new__, just capture the inference dense shape and call parent.
+    if 'tensor_core_shape' in kwargs:
+      cls._tensor_core_shape = kwargs['tensor_core_shape']
+      del kwargs['tensor_core_shape']
+    if 'embedding_lookup_device' in kwargs:
+      cls._embedding_lookup_device = kwargs['embedding_lookup_device']
+      del kwargs['embedding_lookup_device']
+    return _TPUEmbeddingColumnV2.__new__(cls, *args, **kwargs)  # pytype: disable=wrong-keyword-args  # always-use-return-annotations
+
+  def __init__(self, *args, **kwargs):
+    # For __init__, just capture the inference dense shape and call parent.
+    if 'tensor_core_shape' in kwargs:
+      self._tensor_core_shape = kwargs['tensor_core_shape']
+      del kwargs['tensor_core_shape']
+    if 'embedding_lookup_device' in kwargs:
+      self._embedding_lookup_device = kwargs['embedding_lookup_device']
+      del kwargs['embedding_lookup_device']
+    _TPUEmbeddingColumnV2.__init__(self, *args, **kwargs)
+
+  def __deepcopy__(self, memo):
+    return _TPUDeviceSpecificEmbeddingColumnV2(
+        *(copy.deepcopy(a, memo) for a in self.__getnewargs__()),
+        tensor_core_shape=self._tensor_core_shape,
+        embedding_lookup_device=self._embedding_lookup_device)
+
+  def create_state(self, state_manager):
+    _check_invalid_cases(self._embedding_lookup_device)
+    # CPU case.
+    is_cpu = self._embedding_lookup_device == EmbeddingDevice.CPU
+    is_cpu = is_cpu or _is_running_on_cpu()
+    if is_cpu:
+      return fc_lib.EmbeddingColumn.create_state(self, state_manager)
+    # TPU_EMBEDDING_CORE case.
+    elif self._embedding_lookup_device == EmbeddingDevice.TPU_EMBEDDING_CORE:
+      return super(_TPUDeviceSpecificEmbeddingColumnV2,
+                   self).create_state(state_manager)
+
+    # TPU_EMBEDDING_CORE case.
+    return fc_lib.EmbeddingColumn.create_state(self, state_manager)
+
+  def get_dense_tensor(self, transformation_cache, state_manager):
+    """Private method that follows get_dense_tensor."""
+    _check_invalid_cases(self._embedding_lookup_device)
+    # CPU Case.
+    is_cpu = self._embedding_lookup_device == EmbeddingDevice.CPU
+    is_cpu = is_cpu or _is_running_on_cpu()
+    if is_cpu:
+      return super(_TPUDeviceSpecificEmbeddingColumnV2,
+                   self).get_dense_tensor(transformation_cache, state_manager)
+    # TPU_EMBEDDING_CORE case.
+    elif self._embedding_lookup_device == EmbeddingDevice.TPU_EMBEDDING_CORE:
+      return super(_TPUDeviceSpecificEmbeddingColumnV2,
+                   self).get_dense_tensor(transformation_cache, state_manager)
+
+    # TPU_EMBEDDING_CORE cases.
+    if tpu.under_tpu_inference_context():
+      # For inference, use outside compile to densify and pad the input tensors.
+      sparse_tensor = transformation_cache.get(self.categorical_column.name,
+                                               state_manager)
+
+      def host_computation():
+        return pad_sparse_embedding_lookup_indices(sparse_tensor,
+                                                   self._tensor_core_shape[1])
+
+      values, mask = tpu_replication.outside_compilation(host_computation)
+    else:
+      # For training, the inputs should already have been densified and padded.
+      values = transformation_cache.get(self.categorical_column.name,
+                                        state_manager)
+      mask = transformation_cache.get(
+          self.categorical_column.name + _TENSOR_CORE_MASK_KEY_SUFFIX,
+          state_manager)
+    embedding_weights = state_manager.get_variable(
+        self, name='embedding_weights')
+    return sparse_embedding_aggregate_slice(embedding_weights, (values, mask),
+                                            self.get_combiner())
+
+  def _get_dense_tensor(self, inputs, weight_collections=None, trainable=None):
+    _check_invalid_cases(self._embedding_lookup_device)
+    # CPU Case.
+    is_cpu = self._embedding_lookup_device == EmbeddingDevice.CPU
+    is_cpu = is_cpu or _is_running_on_cpu()
+    if is_cpu:
+      return super(_TPUDeviceSpecificEmbeddingColumnV2,
+                   self)._get_dense_tensor(inputs, weight_collections,
+                                           trainable)
+    # TPU_EMBEDDING_CORE case.
+    elif self._embedding_lookup_device == EmbeddingDevice.TPU_EMBEDDING_CORE:
+      return super(_TPUDeviceSpecificEmbeddingColumnV2,
+                   self)._get_dense_tensor(inputs, weight_collections,
+                                           trainable)
+
+    # TPU_EMBEDDING_CORE cases.
+    if tpu.under_tpu_inference_context():
+      # For inference, use outside compile to densify and pad the input tensors.
+      sparse_tensor = inputs.get(self.get_feature_key_name())
+
+      def host_computation():
+        return pad_sparse_embedding_lookup_indices(sparse_tensor,
+                                                   self._tensor_core_shape[1])
+
+      values, mask = tpu_replication.outside_compilation(host_computation)
+    else:
+      # For training, the inputs should already have been densified and padded.
+      values = inputs.get(self.get_feature_key_name())
+      mask = inputs.get(self.get_feature_key_name() +
+                        _TENSOR_CORE_MASK_KEY_SUFFIX)
+
+    embedding_shape = (self.categorical_column._num_buckets, self.dimension)  # pylint: disable=protected-access
+    if (weight_collections and
+        ops.GraphKeys.GLOBAL_VARIABLES not in weight_collections):
+      weight_collections.append(ops.GraphKeys.GLOBAL_VARIABLES)
+    embedding_weights = variable_scope.get_variable(
+        name='embedding_weights',
+        shape=embedding_shape,
+        dtype=dtypes.float32,
+        initializer=self.initializer,
+        trainable=self.trainable and trainable,
+        collections=weight_collections)
+    return sparse_embedding_aggregate_slice(embedding_weights, (values, mask),
+                                            self.get_combiner())
+
+
+class _TPUSharedDeviceSpecificEmbeddingColumnV2(_TPUSharedEmbeddingColumnV2):
+  """TPUSharedEmbeddingColumnV2 which allows serving on TensorCore."""
+
+  def __new__(cls, *args, **kwargs):
+    # For __new__, just capture the inference dense shape and call parent.
+    if 'tensor_core_shape' in kwargs:
+      cls._tensor_core_shape = kwargs['tensor_core_shape']
+      del kwargs['tensor_core_shape']
+    if 'embedding_lookup_device' in kwargs:
+      cls._embedding_lookup_device = kwargs['embedding_lookup_device']
+      del kwargs['embedding_lookup_device']
+
+    return _TPUSharedEmbeddingColumnV2.__new__(cls, *args, **kwargs)  # pytype: disable=wrong-keyword-args  # always-use-return-annotations
+
+  def __init__(self, *args, **kwargs):
+    # For __init__, just capture the inference dense shape and call parent.
+    if 'tensor_core_shape' in kwargs:
+      self._tensor_core_shape = kwargs['tensor_core_shape']
+      del kwargs['tensor_core_shape']
+    if 'embedding_lookup_device' in kwargs:
+      self._embedding_lookup_device = kwargs['embedding_lookup_device']
+      del kwargs['embedding_lookup_device']
+    _TPUSharedEmbeddingColumnV2.__init__(self, *args, **kwargs)
+
+  def __deepcopy__(self, memo):
+    return _TPUSharedDeviceSpecificEmbeddingColumnV2(
+        *(copy.deepcopy(a, memo) for a in self.__getnewargs__()),
+        tensor_core_shape=self._tensor_core_shape,
+        embedding_lookup_device=self._embedding_lookup_device)
+
+  def _get_dense_tensor_internal(self, transformation_cache, state_manager):
+    """Private method that follows _get_dense_tensor_internal."""
+    _check_invalid_cases(self._embedding_lookup_device)
+    # CPU Case.
+    is_cpu = self._embedding_lookup_device == EmbeddingDevice.CPU
+    is_cpu = is_cpu or _is_running_on_cpu()
+    if is_cpu:
+      return super(_TPUSharedDeviceSpecificEmbeddingColumnV2,
+                   self)._get_dense_tensor_internal(transformation_cache,
+                                                    state_manager)
+    # TPU_EMBEDDING_CORE case.
+    if self._embedding_lookup_device == EmbeddingDevice.TPU_EMBEDDING_CORE:
+      return super(_TPUSharedDeviceSpecificEmbeddingColumnV2,
+                   self)._get_dense_tensor_internal(transformation_cache,
+                                                    state_manager)
+
+    # TPU_EMBEDDING_CORE cases.
+    if tpu.under_tpu_inference_context():
+      # For inference, use outside compile to densify and pad the input tensors.
+      sparse_tensor = transformation_cache.get(self.categorical_column.name,
+                                               state_manager)
+
+      def host_computation():
+        return pad_sparse_embedding_lookup_indices(sparse_tensor,
+                                                   self._tensor_core_shape[1])
+
+      values, mask = tpu_replication.outside_compilation(host_computation)
+    else:
+      # For training, the inputs should already have been densified and padded.
+      values = transformation_cache.get(self.categorical_column.name,
+                                        state_manager)
+      mask = transformation_cache.get(
+          self.categorical_column.name + _TENSOR_CORE_MASK_KEY_SUFFIX,
+          state_manager)
+
+    # Do a dense embedding lookup on TensorCore.
+    embedding_weights = self.shared_embedding_column_creator.embedding_weights
+    return sparse_embedding_aggregate_slice(embedding_weights, (values, mask),
+                                            self.get_combiner())

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/functional.py

@@ -0,0 +1,19 @@
+# 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.
+# =============================================================================
+"""Functional operations."""
+
+from tensorflow.python.tpu.ops import tpu_ops
+
+TPUPartitionedCall = tpu_ops.tpu_partitioned_call  # pylint: disable=invalid-name

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/preempted_hook.py

@@ -0,0 +1,89 @@
+# 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.
+# ==============================================================================
+"""Implementation of the SessionRunHook for preemptible Cloud TPUs."""
+
+import logging as _logging
+import os
+import threading
+import time
+
+from tensorflow.python.distribute.cluster_resolver import tpu_cluster_resolver
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.training import session_run_hook
+
+
+class CloudTPUPreemptedHook(session_run_hook.SessionRunHook):
+  """The SessionRunHook for preemptible Cloud TPUs.
+
+  This is an implementation of SessionRunHook for the pre-emptible Google Cloud
+  TPU service. It attempts to close the session if the TPU is preempted, and
+  exits the coordinator process if the session cannot be closed.
+  """
+
+  def __init__(self, cluster):
+    self._cluster = cluster
+
+  def after_create_session(self, session, coord):
+    if tpu_cluster_resolver.is_running_in_gce():
+      self._tpu_poller = _TPUPollingThread(self._cluster, session)
+      self._tpu_poller.start()
+
+  def end(self, session):
+    self._tpu_poller.stop()
+
+
+class _TPUPollingThread(threading.Thread):
+  """A thread that polls the state of a TPU node.
+
+  When the node transitions into a TERMINAL state (PREEMPTED, TERMINATED)
+  that's considered as not recoverable by the underlying infrastructure,
+  it attempts to close the session, and exits the entire process if the
+  session.close() stucks.
+  """
+
+  def __init__(self, cluster, session):
+    super(_TPUPollingThread, self).__init__()
+
+    self.daemon = True
+    self._running = True
+    self._session_closed = False
+    self._cluster = cluster
+    self._session = session
+    self._interval = 30
+
+    # Some of the Google API libraries are quite chatty, so disable them.
+    for name in ['googleapiclient.discovery', 'oauth2client.client']:
+      _logging.getLogger(name).setLevel(_logging.WARNING)
+
+  def stop(self):
+    self._running = False
+    self._session_closed = True
+    self.join()
+
+  def run(self):
+    if not tpu_cluster_resolver.is_running_in_gce():
+      logging.warning(
+          'TPUPollingThread is running in a non-GCE environment, exiting...')
+      self._running = False
+      return
+
+    while self._running:
+      recoverable = self._cluster._cloud_tpu_client.recoverable()  # pylint: disable=protected-access
+      if not recoverable:
+        logging.warning(
+            'TPUPollingThread found TPU %s in state %s',
+            self._cluster._tpu, self._cluster._cloud_tpu_client.state())  # pylint: disable=protected-access
+        os._exit(1)  # pylint: disable=protected-access
+      time.sleep(self._interval)

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/tensor_tracer_flags.py

@@ -0,0 +1,504 @@
+# 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 to handle tensor tracer parameters."""
+
+
+import os
+import os.path
+import re
+from absl import flags
+from tensorflow.python.ops import linalg_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.platform import tf_logging as logging
+
+TRACE_MODE_PART_TENSOR = 'part-tensor'
+TRACE_MODE_FULL_TENSOR = 'full-tensor'
+TRACE_MODE_FULL_TENSOR_SUMMARY = 'full_tensor_summary'
+
+TRACE_MODE_NAN_INF = 'nan-inf'
+TRACE_MODE_NORM = 'norm'
+TRACE_MODE_MAX_ABS = 'max-abs'
+TRACE_MODE_SUMMARY = 'summary'
+TRACE_MODE_HISTORY = 'history'
+# summary mode to collects a finite set of signatures for each traced tensor,
+# (such as norm, max, min, mean) and dumps it using tb summaries.
+
+# Full tensor mode dumps the whole tensor values for the traced tensors without
+# any processing on them; using tb summaries.
+
+_SUBMODE_BRIEF = 'brief'
+_SUBMODE_DETAILED = 'detailed'
+
+_FLAG_SINGLE_QUOTE_PAT = re.compile(r"\s*--([^=]+)='([^']*)'")
+_FLAG_DOUBLE_QUOTE_PAT = re.compile(r'\s*--([^=]+)="([^"]*)"')
+_FLAG_NO_QUOTE_PAT = re.compile(r'\s*--([^=]+)=(\S*)')
+_FLAG_NO_EQUAL_PAT = re.compile(r'\s*--([^=]+)\s*')
+
+FLAGS_ENV_VAR = 'TENSOR_TRACER_FLAGS'
+FLAG_NAME_ENABLE = 'enable'
+FLAG_NAME_TRACE_MODE = 'trace_mode'
+FLAG_NAME_TRACE_SCALAR_OPS = 'trace_scalar'
+FLAG_NAME_SUBMODE = 'submode'
+FLAG_NAME_EXCLUDED_OPNAMES = 'excluded_opnames'
+FLAG_NAME_EXCLUDED_OPTYPES = 'excluded_optypes'
+FLAG_NAME_INCLUDED_OPNAMES = 'included_opnames'
+FLAG_NAME_INCLUDED_OPTYPES = 'included_optypes'
+FLAG_NAME_TRACE_LEVEL = 'trace_level'
+FLAG_NAME_TRACE_DIR = 'trace_dir'
+FLAG_NAME_REPORT_FILE = 'report_file'
+FLAG_NAME_USE_TEST_UNDECLARED_OUTPUTS_DIR = 'use_test_undeclared_outputs_dir'
+FLAG_NAME_OP_RANGE = 'op_range'
+# Folder to dump the pre (before tensor tracer updates) and post graphs (after
+# tensor tracer updates).
+FLAG_NAME_DUMP_BEFORE_AFTER_GRAPHS = 'dump_graphs'
+FLAG_NAME_SUMMARY_SIGNATURES = 'signatures'
+FLAG_NAME_SUMMARY_PER_CORE = 'collect_summary_per_core'
+FLAG_NAME_TEMP_CACHE_VAR = 'use_temp_cache'
+FLAG_NAME_INSPECT_TRACE = 'inspect_trace'
+FLAG_NAME_FINGERPRINT_DIR = 'use_fingerprint_subdirectory'
+FLAG_FLUSH_SUMMARY = 'flush_summaries'
+
+
+VALID_FLAG_NAMES = [
+    FLAG_NAME_ENABLE, FLAG_NAME_TRACE_MODE,
+    FLAG_NAME_TRACE_SCALAR_OPS,
+    FLAG_NAME_SUBMODE, FLAG_NAME_EXCLUDED_OPNAMES,
+    FLAG_NAME_EXCLUDED_OPTYPES, FLAG_NAME_INCLUDED_OPNAMES,
+    FLAG_NAME_INCLUDED_OPTYPES, FLAG_NAME_TRACE_DIR,
+    FLAG_NAME_REPORT_FILE,
+    FLAG_NAME_USE_TEST_UNDECLARED_OUTPUTS_DIR,
+    FLAG_NAME_OP_RANGE,
+    FLAG_NAME_DUMP_BEFORE_AFTER_GRAPHS, FLAG_NAME_TRACE_LEVEL,
+    FLAG_NAME_SUMMARY_SIGNATURES, FLAG_NAME_SUMMARY_PER_CORE,
+    FLAG_NAME_TEMP_CACHE_VAR, FLAG_NAME_FINGERPRINT_DIR,
+    FLAG_NAME_INSPECT_TRACE, FLAG_FLUSH_SUMMARY,
+]
+
+_OP_RANGE_PAT = re.compile(r'(\d+):(\d+)')
+_TEST_UNDECLARED_OUTPUTS_DIR_ENV_VAR = 'TEST_UNDECLARED_OUTPUTS_DIR'
+
+_TT_DEFAULT_TRACE_LEVEL = 3
+_TT_PREFIX = 'tensor_tracer'
+
+_TT_NORM = 'norm'
+_TT_MAX = 'max'
+_TT_MAX_ABS = 'max-abs'
+_TT_MIN = 'min'
+_TT_SPARSITY = 'sparsity'
+_TT_MEAN = 'mean'
+_TT_VAR = 'var'
+_TT_SIZE = 'size'
+
+TT_SUMMARY_NORM = '%s_%s' % (_TT_PREFIX, _TT_NORM)
+TT_SUMMARY_MAX = '%s_%s' % (_TT_PREFIX, _TT_MAX)
+TT_SUMMARY_MAX_ABS = '%s_%s' % (_TT_PREFIX, _TT_MAX_ABS)
+TT_SUMMARY_MIN = '%s_%s' % (_TT_PREFIX, _TT_MIN)
+TT_SUMMARY_SPARSITY = '%s_%s' % (_TT_PREFIX, _TT_SPARSITY)
+TT_SUMMARY_MEAN = '%s_%s' % (_TT_PREFIX, _TT_MEAN)
+TT_SUMMARY_VAR = '%s_%s' % (_TT_PREFIX, _TT_VAR)
+TT_SUMMARY_SIZE = '%s_%s' % (_TT_PREFIX, _TT_SIZE)
+
+TT_SUMMARY_SIGNATURES = (TT_SUMMARY_NORM, TT_SUMMARY_MAX, TT_SUMMARY_MIN,
+                         TT_SUMMARY_SPARSITY, TT_SUMMARY_MEAN, TT_SUMMARY_VAR,
+                         TT_SUMMARY_SIZE, TT_SUMMARY_MAX_ABS)
+
+FLAGS = flags.FLAGS
+
+DELTA_THRESHOLD = flags.DEFINE_float(
+    'delta_threshold',
+    default=0.5,
+    help=('Log if history based diff crosses this threshold.'))
+TT_CHECK_FILTER = flags.DEFINE_bool(
+    'tt_check_filter',
+    default=False,
+    help='Terminate early to check op name filtering.')
+TT_SINGLE_CORE_SUMMARIES = flags.DEFINE_bool(
+    'tt_single_core_summaries',
+    default=False,
+    help='Report single core metric and avoid aggregation.')
+
+
+class TTParameters(object):
+  """A class that handles the parameters of Tensor Tracer."""
+
+  def __init__(self, env=None):
+    if env:
+      self._env = env
+    else:
+      self._env = os.environ
+    self._validate_flag_names()
+    self.trace_mode = self._get_trace_mode()
+    self.submode = self._get_submode()
+    self.trace_dir = self._get_trace_dir()
+    self.report_file_path = self._get_report_filepath()
+    self.op_range = self._get_op_range()
+    self.excluded_opname_re_list = self._flag_value_to_re_list(
+        FLAG_NAME_EXCLUDED_OPNAMES)
+    self.excluded_optype_re_list = self._flag_value_to_re_list(
+        FLAG_NAME_EXCLUDED_OPTYPES)
+
+    self.included_opname_re_list = self._flag_value_to_re_list(
+        FLAG_NAME_INCLUDED_OPNAMES)
+    self.included_optype_re_list = self._flag_value_to_re_list(
+        FLAG_NAME_INCLUDED_OPTYPES)
+
+    self.trace_scalar_ops = self.is_flag_on(FLAG_NAME_TRACE_SCALAR_OPS)
+    self.use_compact_trace = self.trace_mode in (TRACE_MODE_NAN_INF,
+                                                 TRACE_MODE_NORM,
+                                                 TRACE_MODE_HISTORY,
+                                                 TRACE_MODE_MAX_ABS,
+                                                 TRACE_MODE_SUMMARY)
+    self.use_temp_cache_var = self.is_flag_on(FLAG_NAME_TEMP_CACHE_VAR)
+    self.inspect_trace = self.is_flag_on(FLAG_NAME_INSPECT_TRACE)
+    self.use_fingerprint_subdir = self.is_flag_on(FLAG_NAME_FINGERPRINT_DIR)
+
+    _, self.graph_dump_path = self.get_flag_value(
+        FLAG_NAME_DUMP_BEFORE_AFTER_GRAPHS)
+    self.trace_level = self._get_flag_int_value(FLAG_NAME_TRACE_LEVEL,
+                                                _TT_DEFAULT_TRACE_LEVEL)
+    self.summary_signatures = self._get_summary_signatures()
+    self.collect_summary_per_core = self.is_flag_on(FLAG_NAME_SUMMARY_PER_CORE)
+    # TODO(b/199284834): Will be resolved with referenced bug.
+    if self.collect_summary_per_core:
+      logging.warning('Aggregate signatures are approximate for mean, variance'
+                      ' and sparsity.')
+    self.flush_summaries_with_outside_compile = self.is_flag_on(
+        FLAG_FLUSH_SUMMARY)
+    # Do not produce errors or warnings if Tensor Tracer is not enabled.
+    if self.is_enabled():
+      self._check_flag_errors()
+
+  def _check_flag_errors(self):
+    if self.trace_mode in (TRACE_MODE_SUMMARY, TRACE_MODE_FULL_TENSOR_SUMMARY):
+      if not self.trace_dir:
+        raise ValueError('trace_dir must be explicitly provided in '
+                         'TENSOR_TRACER_FLAGS when summary mode is used.')
+
+  def _get_report_filepath(self):
+    """Sets the path of the output report file."""
+
+    found, report_file_path = self.get_flag_value(FLAG_NAME_REPORT_FILE)
+    if found and report_file_path and self.use_test_undeclared_outputs_dir():
+      if os.path.isabs(report_file_path):
+        raise ValueError('If use_test_undeclared_outputs_dir is set,'
+                         'report_file_path cannot be an absolute path (%s)'
+                         %report_file_path)
+      outputs_dir = self._env.get(_TEST_UNDECLARED_OUTPUTS_DIR_ENV_VAR)
+      report_file_path = os.path.join(outputs_dir, report_file_path)
+    return report_file_path
+
+  def _get_op_range(self):
+    """Sets the index range of the Ops that we will consider tracing."""
+    found, op_range = self.get_flag_value(FLAG_NAME_OP_RANGE)
+    if not found or not op_range:
+      op_range = (-1, -1)  # this means including all ops.
+      return op_range
+    match = _OP_RANGE_PAT.match(op_range)
+    if not match:
+      op_range = (-1, -1)  # this means including all ops.
+      return op_range
+    op_range = (int(match.group(1)), int(match.group(2)))
+    return op_range
+
+  def _get_trace_dir(self):
+    found, trace_dir = self.get_flag_value(FLAG_NAME_TRACE_DIR)
+    if found and trace_dir and self.use_test_undeclared_outputs_dir():
+      raise ValueError(
+          'Cannot not use --%s and --%s at the same time' %
+          (FLAG_NAME_TRACE_DIR, FLAG_NAME_USE_TEST_UNDECLARED_OUTPUTS_DIR))
+    if self.use_test_undeclared_outputs_dir():
+      trace_dir = self._env.get(_TEST_UNDECLARED_OUTPUTS_DIR_ENV_VAR)
+    return trace_dir
+
+  def _get_trace_mode(self):
+    """Checks if the given trace mode is valid."""
+
+    found, trace_mode = self.get_flag_value(FLAG_NAME_TRACE_MODE)
+    if not found or not trace_mode:
+      trace_mode = TRACE_MODE_NORM
+    valid_trace_modes = [
+        TRACE_MODE_NAN_INF, TRACE_MODE_PART_TENSOR, TRACE_MODE_FULL_TENSOR,
+        TRACE_MODE_NORM, TRACE_MODE_MAX_ABS,
+        TRACE_MODE_SUMMARY, TRACE_MODE_FULL_TENSOR_SUMMARY,
+        TRACE_MODE_HISTORY
+    ]
+    if trace_mode not in valid_trace_modes:
+      raise ValueError('Invalid trace mode "%s" given to the Tensor_Tracer.'
+                       'Valid trace modes are: %s'%(trace_mode,
+                                                    valid_trace_modes))
+    return trace_mode
+
+  def is_brief_mode(self):
+    return self.submode == _SUBMODE_BRIEF
+
+  def _get_submode(self):
+    """Checks if the given submode is valid."""
+
+    found, submode = self.get_flag_value(FLAG_NAME_SUBMODE)
+    if not found or not submode:
+      submode = _SUBMODE_DETAILED
+    if not submode:
+      return
+    valid_submodes = [_SUBMODE_DETAILED, _SUBMODE_BRIEF]
+    if submode not in valid_submodes:
+      raise ValueError('Invalid submode "%s" given to the Tensor_Tracer.'
+                       'Valid submodes are: %s'%(submode,
+                                                 valid_submodes))
+    return submode
+
+  @staticmethod
+  def match_next_flag(tt_flags, pos):
+    """Returns the match for the next TensorTracer flag.
+
+    Args:
+       tt_flags: a string that contains the flags.
+       pos: where in flags to start the search.
+
+    Returns:
+       A pair where the first element is the regular-expression
+       match found and the second element indicates if the match
+       has a value.
+    """
+
+    match = _FLAG_DOUBLE_QUOTE_PAT.match(tt_flags, pos)
+    if match:
+      return match, True
+    match = _FLAG_SINGLE_QUOTE_PAT.match(tt_flags, pos)
+    if match:
+      return match, True
+    match = _FLAG_NO_QUOTE_PAT.match(tt_flags, pos)
+    if match:
+      return match, True
+    match = _FLAG_NO_EQUAL_PAT.match(tt_flags, pos)
+    if match:
+      # The flag is found but is not given a value.
+      return match, False
+    # The flag is not found.
+    return None, False
+
+  def _validate_flag_names(self):
+    """Validates if the TensorTrace flags passed are valid."""
+    tensor_tracer_flags = self._env.get(FLAGS_ENV_VAR)
+    if not tensor_tracer_flags:
+      return
+    pos = 0
+    while True:
+      match, _ = TTParameters.match_next_flag(tensor_tracer_flags, pos)
+      if not match:
+        break
+      flag_name = match.group(1)
+      if flag_name not in VALID_FLAG_NAMES:
+        raise ValueError(
+            'The flag name "%s" passed via the environment variable "%s" '
+            'is invalid. Valid flag names are:'
+            '\n%s' % (flag_name, FLAGS_ENV_VAR, VALID_FLAG_NAMES))
+      pos = match.end()
+
+  def _supported_signatures(self):
+    """Returns a tuple of supported signatures."""
+    return TT_SUMMARY_SIGNATURES
+
+  def _get_summary_signatures(self):
+    """Verifies and returns the summary signatures.
+
+    Returns:
+      A dictionary of the signature identifiers {signature: index} that will be
+      computed when trace_mode is summary.
+    """
+    signatures = self._flag_value_as_list(FLAG_NAME_SUMMARY_SIGNATURES)
+    supported_signatures = self._supported_signatures()
+
+    tt_signatures = []
+    for signature in signatures:
+      signature_with_prefix = '%s_%s' % (_TT_PREFIX, signature)
+      if signature in supported_signatures:
+        tt_signatures.append(signature)
+      elif signature_with_prefix in supported_signatures:
+        tt_signatures.append(signature_with_prefix)
+      else:
+        logging.warning('Unknown signature:%s. Supported signatures: %s' %
+                        (signature, supported_signatures))
+    if not tt_signatures:
+      # Default case collects norm and max only.
+      return {TT_SUMMARY_MAX_ABS: 0, TT_SUMMARY_NORM: 1}
+    else:
+      return {signature: idx for idx, signature in enumerate(tt_signatures)}
+
+  def get_signature_to_agg_fn_map(self):
+    """Returns a map that contains the aggregate function for each signature."""
+    # TODO(b/199284834): Aggregations are not accurate for mean and sparsity if
+    # cores have a different number of elements. Variance uses the maximal core
+    # variance.
+    return {TRACE_MODE_NORM: linalg_ops.norm,
+            TRACE_MODE_HISTORY: math_ops.reduce_max,
+            TRACE_MODE_MAX_ABS: math_ops.reduce_max,
+            TRACE_MODE_NAN_INF: math_ops.reduce_max,
+            TT_SUMMARY_NORM: linalg_ops.norm,
+            TT_SUMMARY_MAX: math_ops.reduce_max,
+            TT_SUMMARY_MAX_ABS:
+                lambda t, axis=0: math_ops.reduce_max(math_ops.abs(t),  # pylint: disable=g-long-lambda
+                                                      axis=axis),
+            TT_SUMMARY_MIN: math_ops.reduce_min,
+            # Exact if each part has the same number of values.
+            TT_SUMMARY_SPARSITY: math_ops.reduce_mean,
+            TT_SUMMARY_MEAN: math_ops.reduce_mean,
+            TT_SUMMARY_VAR: math_ops.reduce_max,  # Simply reduce max variance.
+            TT_SUMMARY_SIZE: math_ops.reduce_sum}
+
+  def _flag_value_as_list(self, wanted_flag_name):
+    """Returns the string list of a TensorTracer flag.
+
+    Args:
+      wanted_flag_name: the name of the flag we are looking for.
+
+    Returns:
+      The list value of the flag.
+    """
+    string_value_list = []
+    found, flag_value = self.get_flag_value(wanted_flag_name)
+
+    if found:
+      assert flag_value is not None
+      string_value_list = flag_value.split(',')
+    return string_value_list
+
+  def _flag_value_as_int_list(self, wanted_flag_name):
+    """Returns the integer list of a TensorTracer flag.
+
+    Args:
+      wanted_flag_name: the name of the flag we are looking for.
+
+    Returns:
+      the value of the flag.
+    Raises:
+      RuntimeError: If supposedly deadcode is reached.
+    """
+    int_list = []
+    found, flag_value = self.get_flag_value(wanted_flag_name)
+
+    if found and flag_value:
+      try:
+        integer_values = flag_value.split(',')
+        int_list = [int(int_val) for int_val in integer_values]
+      except ValueError:
+        logging.warning('Cannot convert %s to int for flag %s', int_list,
+                        wanted_flag_name)
+    return int_list
+
+  def _get_flag_int_value(self, wanted_flag_name, default_value):
+    """Returns the int value of a TensorTracer flag.
+
+    Args:
+      wanted_flag_name: the name of the flag we are looking for.
+      default_value: the default value for the flag, if not provided.
+    Returns:
+      the value of the flag.
+    Raises:
+      RuntimeError: If supposedly deadcode is reached.
+    """
+    flag_int_value = default_value
+    found, flag_value = self.get_flag_value(wanted_flag_name)
+
+    if found:
+      try:
+        flag_int_value = int(flag_value)
+      except ValueError:
+        logging.warning('Cannot convert %s to int for flag %s' % (
+            flag_int_value, wanted_flag_name))
+    return flag_int_value
+
+  def get_flag_value(self, wanted_flag_name):
+    """Returns the value of a TensorTracer flags.
+
+    Args:
+      wanted_flag_name: the name of the flag we are looking for.
+
+    Returns:
+      A pair where the first element indicates if the flag is
+      found and the second element is the value of the flag.
+
+    Raises:
+      RuntimeError: If supposedly deadcode is reached.
+    """
+
+    tensor_tracer_flags = self._env.get(FLAGS_ENV_VAR)
+    if not tensor_tracer_flags:
+      return False, None
+    pos = 0
+    while True:
+      match, has_value = TTParameters.match_next_flag(
+          tensor_tracer_flags, pos)
+      if not match:
+        return False, None
+      flag_name = match.group(1)
+      if has_value:
+        flag_value = match.group(2)
+      else:
+        flag_value = None
+      if flag_name == wanted_flag_name:
+        return True, flag_value
+      pos = match.end()
+    raise RuntimeError('Invalid tensor tracer flag. Could not recognize %s.' %
+                       flag_name)
+
+  def _flag_value_to_re_list(self, flag_name):
+    """Converts list of strings to compiled RE."""
+
+    re_list = []
+    found, flag_value = self.get_flag_value(flag_name)
+    if not found or not flag_value:
+      return re_list
+    list_of_values = flag_value.split(',')
+    for v in list_of_values:
+      r = re.compile(v)
+      re_list.append(r)
+    return re_list
+
+  def is_flag_on(self, flag_name):
+    """Returns True if the given flag is on."""
+
+    found, flag_value = self.get_flag_value(flag_name)
+    if not found:
+      return False
+    if flag_value is None:
+      return True
+    # Depends on the flag value.
+    flag_value = flag_value.lower()
+    enabled = flag_value in ['1', 't', 'true', 'y', 'yes']
+    return enabled
+
+  def is_enabled(self):
+    """Returns True if TensorTracer is enabled."""
+
+    if self.is_flag_on(FLAG_NAME_ENABLE):
+      logging.debug('Tensor Tracer is enabled with flags %s.',
+                    self._env.get(FLAGS_ENV_VAR))
+      return True
+    else:
+      return False
+
+  def use_test_undeclared_outputs_dir(self):
+    """Decides the output directory of the report and trace files.
+
+    Args:
+       None.
+
+    Returns:
+       True if the output files should be written to the
+       test-undeclared-outputs-directory defined via an
+       env variable.
+    """
+
+    return self.is_flag_on(FLAG_NAME_USE_TEST_UNDECLARED_OUTPUTS_DIR)

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/tensor_tracer_pb2.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/python/tpu/tensor_tracer.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()
+
+
+from tensorflow.core.framework import graph_pb2 as tensorflow_dot_core_dot_framework_dot_graph__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)tensorflow/python/tpu/tensor_tracer.proto\x12\ntensorflow\x1a%tensorflow/core/framework/graph.proto\"\xb4\t\n\x12TensorTracerReport\x12\x41\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x31.tensorflow.TensorTracerReport.TensorTracerConfig\x12&\n\x08graphdef\x18\x02 \x01(\x0b\x32\x14.tensorflow.GraphDef\x12@\n\ttensordef\x18\x03 \x03(\x0b\x32-.tensorflow.TensorTracerReport.TensordefEntry\x12\x13\n\x0b\x66ingerprint\x18\x04 \x01(\t\x12\x1e\n\x16\x63oncrete_function_name\x18\x05 \x01(\t\x12\x1c\n\x14last_common_frame_no\x18\x06 \x01(\x05\x12\x0f\n\x07outputs\x18\x07 \x03(\t\x12\x42\n\rtracing_stats\x18\x08 \x01(\x0b\x32+.tensorflow.TensorTracerReport.TracingStats\x1a`\n\x0eTensordefEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12=\n\x05value\x18\x02 \x01(\x0b\x32..tensorflow.TensorTracerReport.TracedTensorDef:\x02\x38\x01\x1a\xc8\x01\n\x12TensorTracerConfig\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x0e\n\x06\x64\x65vice\x18\x02 \x01(\t\x12\x12\n\ntrace_mode\x18\x03 \x01(\t\x12\x11\n\tnum_cores\x18\x04 \x01(\x05\x12\x11\n\tnum_hosts\x18\x05 \x01(\x05\x12\x0f\n\x07submode\x18\x06 \x01(\t\x12\x1a\n\x12num_cores_per_host\x18\x07 \x01(\x05\x12\x16\n\x0eincluded_cores\x18\x08 \x03(\x05\x12\x12\n\nsignatures\x18\t \x03(\t\x1a\xef\x01\n\x0cTracingStats\x12\x15\n\rtotal_tensors\x18\x01 \x01(\x05\x12\x16\n\x0etraced_tensors\x18\x02 \x01(\x05\x12_\n\x13traced_tensor_types\x18\x03 \x03(\x0b\x32\x42.tensorflow.TensorTracerReport.TracingStats.TracedTensorTypesEntry\x12\x15\n\radded_tensors\x18\x04 \x01(\x05\x1a\x38\n\x16TracedTensorTypesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\xa9\x02\n\x0fTracedTensorDef\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x63\x61\x63he_index\x18\x02 \x01(\x05\x12\x18\n\x10trace_point_name\x18\x03 \x01(\t\x12\x11\n\tis_traced\x18\x04 \x01(\x08\x12\x13\n\x0b\x65xplanation\x18\x05 \x01(\t\x12K\n\rop_stack_info\x18\x06 \x01(\x0b\x32\x34.tensorflow.TensorTracerReport.TracedTensorDef.Stack\x1a\x64\n\x05Stack\x12\x16\n\x0estack_fn_names\x18\x01 \x03(\t\x12\x13\n\x0bstack_lines\x18\x02 \x03(\t\x12\x17\n\x0fstack_filenames\x18\x03 \x03(\t\x12\x15\n\rstack_linenos\x18\x04 \x03(\x05\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.python.tpu.tensor_tracer_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _TENSORTRACERREPORT_TENSORDEFENTRY._options = None
+  _TENSORTRACERREPORT_TENSORDEFENTRY._serialized_options = b'8\001'
+  _TENSORTRACERREPORT_TRACINGSTATS_TRACEDTENSORTYPESENTRY._options = None
+  _TENSORTRACERREPORT_TRACINGSTATS_TRACEDTENSORTYPESENTRY._serialized_options = b'8\001'
+  _TENSORTRACERREPORT._serialized_start=97
+  _TENSORTRACERREPORT._serialized_end=1301
+  _TENSORTRACERREPORT_TENSORDEFENTRY._serialized_start=460
+  _TENSORTRACERREPORT_TENSORDEFENTRY._serialized_end=556
+  _TENSORTRACERREPORT_TENSORTRACERCONFIG._serialized_start=559
+  _TENSORTRACERREPORT_TENSORTRACERCONFIG._serialized_end=759
+  _TENSORTRACERREPORT_TRACINGSTATS._serialized_start=762
+  _TENSORTRACERREPORT_TRACINGSTATS._serialized_end=1001
+  _TENSORTRACERREPORT_TRACINGSTATS_TRACEDTENSORTYPESENTRY._serialized_start=945
+  _TENSORTRACERREPORT_TRACINGSTATS_TRACEDTENSORTYPESENTRY._serialized_end=1001
+  _TENSORTRACERREPORT_TRACEDTENSORDEF._serialized_start=1004
+  _TENSORTRACERREPORT_TRACEDTENSORDEF._serialized_end=1301
+  _TENSORTRACERREPORT_TRACEDTENSORDEF_STACK._serialized_start=1201
+  _TENSORTRACERREPORT_TRACEDTENSORDEF_STACK._serialized_end=1301
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/python/tpu/topology.py

@@ -0,0 +1,239 @@
+# 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.
+# ======================================
+"""Defines the `Topology` class, that describes a TPU fabric topology."""
+
+import numpy as np
+
+from tensorflow.core.protobuf.tpu import topology_pb2
+from tensorflow.python.util.tf_export import tf_export
+
+
+def _tpu_device_name(job, task, device):
+  """Returns the device name for the TPU `device` on `task` of `job`."""
+  if job is None:
+    return "/task:%d/device:TPU:%d" % (task, device)
+  else:
+    return "/job:%s/task:%d/device:TPU:%d" % (job, task, device)
+
+
+def _tpu_host_device_name(job, task):
+  """Returns the device name for the CPU device on `task` of `job`."""
+  if job is None:
+    return "/task:%d/device:CPU:0" % task
+  else:
+    return "/job:%s/task:%d/device:CPU:0" % (job, task)
+
+
+@tf_export("tpu.experimental.Topology")
+class Topology(object):
+  """Describes a set of TPU devices.
+
+  Represents both the shape of the physical mesh, and the mapping between
+  TensorFlow TPU devices to physical mesh coordinates.
+  """
+
+  def __init__(self, serialized=None, mesh_shape=None, device_coordinates=None):
+    """Builds a Topology object.
+
+    If `serialized` is not `None`, the topology is parsed from `serialized` and
+    the other arguments are ignored. Otherwise, the topology is computed from
+    `mesh_shape` and `device_coordinates`.
+
+    Args:
+      serialized: A serialized `TopologyProto`, or `None`. If not `None`, the
+        serialized proto is parsed to discover the topology.
+      mesh_shape: A sequence of 4 positive integers, or `None`. If not `None`,
+        the shape of the TPU topology, in number of cores. Ignored if
+        `serialized` is not `None`.
+      device_coordinates: A rank 3 numpy array that describes the mapping from
+        TensorFlow TPU devices to TPU fabric coordinates, or `None`. If
+        specified, array is a rank 3 int32 array with shape
+        `[tasks, devices, axis]`.  `tasks` is the number of tasks in the TPU
+        cluster, `devices` is the number of TPU devices per task, and `axis` is
+        the number of axes in the TPU cluster topology. Each entry gives the
+        `axis`-th coordinate in the topology of a task/device pair. TPU
+        topologies are 4-dimensional, with dimensions `(x, y, z, core number)`.
+        This arg is ignored if `serialized is not `None`.
+
+    Raises:
+      ValueError: If `serialized` does not describe a well-formed topology.
+      ValueError: If `serialized` is `None` and `mesh_shape` is not a sequence
+        of 4 positive integers.
+      ValueError: If `serialized` is `None` and `device_coordinates` is not a
+        rank 3 numpy int32 array that describes a valid coordinate mapping.
+    """
+
+    self._serialized = serialized
+
+    if serialized:
+      self._parse_topology(serialized)
+    else:
+      self._mesh_shape = np.asarray(mesh_shape, dtype=np.int32)
+      self._device_coordinates = np.asarray(device_coordinates, np.int32)
+      if len(self._mesh_shape) != 4 or any(self._mesh_shape < 1):
+        raise ValueError("`mesh_shape` must be a sequence of 4 positive "
+                         f"entries; got `mesh_shape={self._mesh_shape}`")
+
+      if (len(self._device_coordinates.shape) != 3 or
+          self._device_coordinates.shape[2] != len(self._mesh_shape)):
+        raise ValueError(
+            "`device_coordinates` must be a rank 3 int32 array "
+            "with minor dimension equal to the `mesh_shape` rank"
+            "got device_coordinates.shape={} len(device_coordinates.shape)={} device_coordinates.shape[2]={} mesh_shape={}, len(mesh_shape)={}"
+            .format(self._device_coordinates.shape,
+                    len(self._device_coordinates.shape),
+                    self._device_coordinates.shape[2], self._mesh_shape,
+                    len(self._mesh_shape)))
+
+    self._topology_tasks, self._topology_devices = self._invert_topology()
+
+    # Coordinates of devices that are missing
+    self._missing_devices = np.argwhere(self._topology_tasks < 0)
+
+  def _parse_topology(self, serialized):
+    """Parses a serialized `TopologyProto` into `self`."""
+    proto = topology_pb2.TopologyProto()
+    proto.ParseFromString(serialized)
+
+    self._mesh_shape = np.array(proto.mesh_shape, dtype=np.int32)
+    if len(self._mesh_shape) != 4 or any(self._mesh_shape < 1):
+      raise ValueError("`mesh_shape` must be a vector of size 4 with positive "
+                       "entries; got {}".format(self._mesh_shape))
+
+    if proto.num_tasks < 0:
+      raise ValueError("`num_tasks` must be >= 0; got {}".format(
+          proto.num_tasks))
+    if proto.num_tpu_devices_per_task < 0:
+      raise ValueError("`num_tpu_devices_per_task` must be >= 0; got {}".format(
+          proto.num_tpu_devices_per_task))
+
+    expected_coordinates_size = (
+        proto.num_tasks * proto.num_tpu_devices_per_task * len(
+            proto.mesh_shape))
+    if len(proto.device_coordinates) != expected_coordinates_size:
+      raise ValueError("`device_coordinates` must have shape num_tasks ({}) * "
+                       "num_tpu_devices_per_task ({}) * len(mesh_shape) ({}); "
+                       "got shape {}".format(proto.num_tasks,
+                                             proto.num_tpu_devices_per_task,
+                                             proto.mesh_shape,
+                                             len(proto.device_coordinates)))
+
+    coords = np.array(proto.device_coordinates, dtype=np.int32)
+    if any(coords < 0):
+      raise ValueError(
+          "All values in `device_coordinates` must be >= 0, got {}"
+          .format(coords))
+    coords = coords.reshape((proto.num_tasks, proto.num_tpu_devices_per_task,
+                             len(proto.mesh_shape)))
+    self._device_coordinates = coords
+
+  def _invert_topology(self):
+    """Inverts a [task,device,axis] topology to [x,y,z] -> task/device maps."""
+    tasks = np.full(list(self.mesh_shape), -1, dtype=np.int32)
+    devices = np.full(list(self.mesh_shape), -1, dtype=np.int32)
+    for task in range(self.device_coordinates.shape[0]):
+      for device in range(self.device_coordinates.shape[1]):
+        x, y, z, core = self.device_coordinates[task, device, :]
+        tasks[x, y, z, core] = task
+        devices[x, y, z, core] = device
+    return tasks, devices
+
+  @property
+  def mesh_shape(self):
+    """A rank 1 int32 array describing the shape of the TPU topology."""
+    return self._mesh_shape
+
+  @property
+  def mesh_rank(self):
+    """Returns the number of dimensions in the mesh."""
+    return len(self._mesh_shape)
+
+  @property
+  def device_coordinates(self):
+    """Describes the mapping from TPU devices to topology coordinates.
+
+    Returns:
+      A rank 3 int32 array with shape `[tasks, devices, axis]`.
+      `tasks` is the number of tasks in the TPU cluster, `devices` is the number
+      of TPU devices per task, and `axis` is the number of axes in the TPU
+      cluster topology. Each entry gives the `axis`-th coordinate in the
+      topology of a task/device pair. TPU topologies are 4-dimensional, with
+      dimensions `(x, y, z, core number)`.
+    """
+    return self._device_coordinates
+
+  @property
+  def missing_devices(self):
+    """Array of indices of missing devices."""
+    return self._missing_devices
+
+  def task_ordinal_at_coordinates(self, device_coordinates):
+    """Returns the TensorFlow task number attached to `device_coordinates`.
+
+    Args:
+      device_coordinates: An integer sequence describing a device's physical
+        coordinates in the TPU fabric.
+
+    Returns:
+      Returns the TensorFlow task number that contains the TPU device with those
+      physical coordinates.
+    """
+    return self._topology_tasks[tuple(device_coordinates)]
+
+  def tpu_device_ordinal_at_coordinates(self, device_coordinates):
+    """Returns the TensorFlow device number at `device_coordinates`.
+
+    Args:
+      device_coordinates: An integer sequence describing a device's physical
+        coordinates in the TPU fabric.
+
+    Returns:
+      Returns the TensorFlow device number within the task corresponding to
+      attached to the device with those physical coordinates.
+    """
+    return self._topology_devices[tuple(device_coordinates)]
+
+  def cpu_device_name_at_coordinates(self, device_coordinates, job=None):
+    """Returns the CPU device attached to a logical core."""
+    return _tpu_host_device_name(
+        job, self._topology_tasks[tuple(device_coordinates)])
+
+  def tpu_device_name_at_coordinates(self, device_coordinates, job=None):
+    """Returns the name of the TPU device assigned to a logical core."""
+    return _tpu_device_name(job,
+                            self._topology_tasks[tuple(device_coordinates)],
+                            self._topology_devices[tuple(device_coordinates)])
+
+  @property
+  def num_tasks(self):
+    """Returns the number of TensorFlow tasks in the TPU slice."""
+    return self._device_coordinates.shape[0]
+
+  @property
+  def num_tpus_per_task(self):
+    """Returns the number of TPU devices per task in the TPU slice."""
+    return self._device_coordinates.shape[1]
+
+  def serialized(self):
+    """Returns the serialized form of the topology."""
+    if self._serialized is None:
+      proto = topology_pb2.TopologyProto()
+      proto.mesh_shape[:] = list(self._mesh_shape)
+      proto.num_tasks = self._device_coordinates.shape[0]
+      proto.num_tpu_devices_per_task = self._device_coordinates.shape[1]
+      proto.device_coordinates.extend(list(self._device_coordinates.flatten()))
+      self._serialized = proto.SerializeToString()
+
+    return self._serialized