Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/experimental/microfrontend/ops/gen_audio_microfrontend_op.py

@@ -0,0 +1,423 @@
+"""Python wrappers around TensorFlow ops.
+
+This file is MACHINE GENERATED! Do not edit.
+"""
+
+import collections
+
+from tensorflow.python import pywrap_tfe as pywrap_tfe
+from tensorflow.python.eager import context as _context
+from tensorflow.python.eager import core as _core
+from tensorflow.python.eager import execute as _execute
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.security.fuzzing.py import annotation_types as _atypes
+
+from tensorflow.python.framework import op_def_registry as _op_def_registry
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import op_def_library as _op_def_library
+from tensorflow.python.util.deprecation import deprecated_endpoints
+from tensorflow.python.util import dispatch as _dispatch
+from tensorflow.python.util.tf_export import tf_export
+
+from typing import TypeVar, List, Any
+from typing_extensions import Annotated
+
+TV_AudioMicrofrontend_out_type = TypeVar("TV_AudioMicrofrontend_out_type", _atypes.Float32, _atypes.UInt16)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('audio_microfrontend')
+def audio_microfrontend(audio: Annotated[Any, _atypes.Int16], sample_rate:int=16000, window_size:int=25, window_step:int=10, num_channels:int=32, upper_band_limit:float=7500, lower_band_limit:float=125, smoothing_bits:int=10, even_smoothing:float=0.025, odd_smoothing:float=0.06, min_signal_remaining:float=0.05, enable_pcan:bool=False, pcan_strength:float=0.95, pcan_offset:float=80, gain_bits:int=21, enable_log:bool=True, scale_shift:int=6, left_context:int=0, right_context:int=0, frame_stride:int=1, zero_padding:bool=False, out_scale:int=1, out_type:TV_AudioMicrofrontend_out_type=_dtypes.uint16, name=None) -> Annotated[Any, TV_AudioMicrofrontend_out_type]:
+  r"""Audio Microfrontend Op.
+
+  This Op converts a sequence of audio data into one or more
+  feature vectors containing filterbanks of the input. The
+  conversion process uses a lightweight library to perform:
+
+  1. A slicing window function
+  2. Short-time FFTs
+  3. Filterbank calculations
+  4. Noise reduction
+  5. PCAN Auto Gain Control
+  6. Logarithmic scaling
+
+  Arguments
+    audio: 1D Tensor, int16 audio data in temporal ordering.
+    sample_rate: Integer, the sample rate of the audio in Hz.
+    window_size: Integer, length of desired time frames in ms.
+    window_step: Integer, length of step size for the next frame in ms.
+    num_channels: Integer, the number of filterbank channels to use.
+    upper_band_limit: Float, the highest frequency included in the filterbanks.
+    lower_band_limit: Float, the lowest frequency included in the filterbanks.
+    smoothing_bits: Int, scale up signal by 2^(smoothing_bits) before reduction.
+    even_smoothing: Float, smoothing coefficient for even-numbered channels.
+    odd_smoothing: Float, smoothing coefficient for odd-numbered channels.
+    min_signal_remaining: Float, fraction of signal to preserve in smoothing.
+    enable_pcan: Bool, enable PCAN auto gain control.
+    pcan_strength: Float, gain normalization exponent.
+    pcan_offset: Float, positive value added in the normalization denominator.
+    gain_bits: Int, number of fractional bits in the gain.
+    enable_log: Bool, enable logarithmic scaling of filterbanks.
+    scale_shift: Integer, scale filterbanks by 2^(scale_shift).
+    left_context: Integer, number of preceding frames to attach to each frame.
+    right_context: Integer, number of preceding frames to attach to each frame.
+    frame_stride: Integer, M frames to skip over, where output[n] = frame[n*M].
+    zero_padding: Bool, if left/right context is out-of-bounds, attach frame of
+                  zeroes. Otherwise, frame[0] or frame[size-1] will be copied.
+    out_scale: Integer, divide all filterbanks by this number.
+    out_type: DType, type of the output Tensor, defaults to UINT16.
+
+  Returns
+    filterbanks: 2D Tensor, each row is a time frame, each column is a channel.
+
+  Args:
+    audio: A `Tensor` of type `int16`.
+    sample_rate: An optional `int`. Defaults to `16000`.
+    window_size: An optional `int`. Defaults to `25`.
+    window_step: An optional `int`. Defaults to `10`.
+    num_channels: An optional `int`. Defaults to `32`.
+    upper_band_limit: An optional `float`. Defaults to `7500`.
+    lower_band_limit: An optional `float`. Defaults to `125`.
+    smoothing_bits: An optional `int`. Defaults to `10`.
+    even_smoothing: An optional `float`. Defaults to `0.025`.
+    odd_smoothing: An optional `float`. Defaults to `0.06`.
+    min_signal_remaining: An optional `float`. Defaults to `0.05`.
+    enable_pcan: An optional `bool`. Defaults to `False`.
+    pcan_strength: An optional `float`. Defaults to `0.95`.
+    pcan_offset: An optional `float`. Defaults to `80`.
+    gain_bits: An optional `int`. Defaults to `21`.
+    enable_log: An optional `bool`. Defaults to `True`.
+    scale_shift: An optional `int`. Defaults to `6`.
+    left_context: An optional `int`. Defaults to `0`.
+    right_context: An optional `int`. Defaults to `0`.
+    frame_stride: An optional `int`. Defaults to `1`.
+    zero_padding: An optional `bool`. Defaults to `False`.
+    out_scale: An optional `int`. Defaults to `1`.
+    out_type: An optional `tf.DType` from: `tf.uint16, tf.float32`. Defaults to `tf.uint16`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `out_type`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "AudioMicrofrontend", name, audio, "sample_rate", sample_rate,
+        "window_size", window_size, "window_step", window_step,
+        "num_channels", num_channels, "upper_band_limit", upper_band_limit,
+        "lower_band_limit", lower_band_limit, "smoothing_bits",
+        smoothing_bits, "even_smoothing", even_smoothing, "odd_smoothing",
+        odd_smoothing, "min_signal_remaining", min_signal_remaining,
+        "enable_pcan", enable_pcan, "pcan_strength", pcan_strength,
+        "pcan_offset", pcan_offset, "gain_bits", gain_bits, "enable_log",
+        enable_log, "scale_shift", scale_shift, "left_context", left_context,
+        "right_context", right_context, "frame_stride", frame_stride,
+        "zero_padding", zero_padding, "out_scale", out_scale, "out_type",
+        out_type)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_audio_microfrontend(
+          (audio, sample_rate, window_size, window_step, num_channels,
+          upper_band_limit, lower_band_limit, smoothing_bits, even_smoothing,
+          odd_smoothing, min_signal_remaining, enable_pcan, pcan_strength,
+          pcan_offset, gain_bits, enable_log, scale_shift, left_context,
+          right_context, frame_stride, zero_padding, out_scale, out_type,
+          name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return audio_microfrontend_eager_fallback(
+          audio, sample_rate=sample_rate, window_size=window_size,
+          window_step=window_step, num_channels=num_channels,
+          upper_band_limit=upper_band_limit,
+          lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits,
+          even_smoothing=even_smoothing, odd_smoothing=odd_smoothing,
+          min_signal_remaining=min_signal_remaining, enable_pcan=enable_pcan,
+          pcan_strength=pcan_strength, pcan_offset=pcan_offset,
+          gain_bits=gain_bits, enable_log=enable_log, scale_shift=scale_shift,
+          left_context=left_context, right_context=right_context,
+          frame_stride=frame_stride, zero_padding=zero_padding,
+          out_scale=out_scale, out_type=out_type, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            audio_microfrontend, (), dict(audio=audio,
+                                          sample_rate=sample_rate,
+                                          window_size=window_size,
+                                          window_step=window_step,
+                                          num_channels=num_channels,
+                                          upper_band_limit=upper_band_limit,
+                                          lower_band_limit=lower_band_limit,
+                                          smoothing_bits=smoothing_bits,
+                                          even_smoothing=even_smoothing,
+                                          odd_smoothing=odd_smoothing,
+                                          min_signal_remaining=min_signal_remaining,
+                                          enable_pcan=enable_pcan,
+                                          pcan_strength=pcan_strength,
+                                          pcan_offset=pcan_offset,
+                                          gain_bits=gain_bits,
+                                          enable_log=enable_log,
+                                          scale_shift=scale_shift,
+                                          left_context=left_context,
+                                          right_context=right_context,
+                                          frame_stride=frame_stride,
+                                          zero_padding=zero_padding,
+                                          out_scale=out_scale,
+                                          out_type=out_type, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_audio_microfrontend(
+        (audio, sample_rate, window_size, window_step, num_channels,
+        upper_band_limit, lower_band_limit, smoothing_bits, even_smoothing,
+        odd_smoothing, min_signal_remaining, enable_pcan, pcan_strength,
+        pcan_offset, gain_bits, enable_log, scale_shift, left_context,
+        right_context, frame_stride, zero_padding, out_scale, out_type,
+        name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  if sample_rate is None:
+    sample_rate = 16000
+  sample_rate = _execute.make_int(sample_rate, "sample_rate")
+  if window_size is None:
+    window_size = 25
+  window_size = _execute.make_int(window_size, "window_size")
+  if window_step is None:
+    window_step = 10
+  window_step = _execute.make_int(window_step, "window_step")
+  if num_channels is None:
+    num_channels = 32
+  num_channels = _execute.make_int(num_channels, "num_channels")
+  if upper_band_limit is None:
+    upper_band_limit = 7500
+  upper_band_limit = _execute.make_float(upper_band_limit, "upper_band_limit")
+  if lower_band_limit is None:
+    lower_band_limit = 125
+  lower_band_limit = _execute.make_float(lower_band_limit, "lower_band_limit")
+  if smoothing_bits is None:
+    smoothing_bits = 10
+  smoothing_bits = _execute.make_int(smoothing_bits, "smoothing_bits")
+  if even_smoothing is None:
+    even_smoothing = 0.025
+  even_smoothing = _execute.make_float(even_smoothing, "even_smoothing")
+  if odd_smoothing is None:
+    odd_smoothing = 0.06
+  odd_smoothing = _execute.make_float(odd_smoothing, "odd_smoothing")
+  if min_signal_remaining is None:
+    min_signal_remaining = 0.05
+  min_signal_remaining = _execute.make_float(min_signal_remaining, "min_signal_remaining")
+  if enable_pcan is None:
+    enable_pcan = False
+  enable_pcan = _execute.make_bool(enable_pcan, "enable_pcan")
+  if pcan_strength is None:
+    pcan_strength = 0.95
+  pcan_strength = _execute.make_float(pcan_strength, "pcan_strength")
+  if pcan_offset is None:
+    pcan_offset = 80
+  pcan_offset = _execute.make_float(pcan_offset, "pcan_offset")
+  if gain_bits is None:
+    gain_bits = 21
+  gain_bits = _execute.make_int(gain_bits, "gain_bits")
+  if enable_log is None:
+    enable_log = True
+  enable_log = _execute.make_bool(enable_log, "enable_log")
+  if scale_shift is None:
+    scale_shift = 6
+  scale_shift = _execute.make_int(scale_shift, "scale_shift")
+  if left_context is None:
+    left_context = 0
+  left_context = _execute.make_int(left_context, "left_context")
+  if right_context is None:
+    right_context = 0
+  right_context = _execute.make_int(right_context, "right_context")
+  if frame_stride is None:
+    frame_stride = 1
+  frame_stride = _execute.make_int(frame_stride, "frame_stride")
+  if zero_padding is None:
+    zero_padding = False
+  zero_padding = _execute.make_bool(zero_padding, "zero_padding")
+  if out_scale is None:
+    out_scale = 1
+  out_scale = _execute.make_int(out_scale, "out_scale")
+  if out_type is None:
+    out_type = _dtypes.uint16
+  out_type = _execute.make_type(out_type, "out_type")
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "AudioMicrofrontend", audio=audio, sample_rate=sample_rate,
+                              window_size=window_size,
+                              window_step=window_step,
+                              num_channels=num_channels,
+                              upper_band_limit=upper_band_limit,
+                              lower_band_limit=lower_band_limit,
+                              smoothing_bits=smoothing_bits,
+                              even_smoothing=even_smoothing,
+                              odd_smoothing=odd_smoothing,
+                              min_signal_remaining=min_signal_remaining,
+                              enable_pcan=enable_pcan,
+                              pcan_strength=pcan_strength,
+                              pcan_offset=pcan_offset, gain_bits=gain_bits,
+                              enable_log=enable_log, scale_shift=scale_shift,
+                              left_context=left_context,
+                              right_context=right_context,
+                              frame_stride=frame_stride,
+                              zero_padding=zero_padding, out_scale=out_scale,
+                              out_type=out_type, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          audio_microfrontend, (), dict(audio=audio, sample_rate=sample_rate,
+                                        window_size=window_size,
+                                        window_step=window_step,
+                                        num_channels=num_channels,
+                                        upper_band_limit=upper_band_limit,
+                                        lower_band_limit=lower_band_limit,
+                                        smoothing_bits=smoothing_bits,
+                                        even_smoothing=even_smoothing,
+                                        odd_smoothing=odd_smoothing,
+                                        min_signal_remaining=min_signal_remaining,
+                                        enable_pcan=enable_pcan,
+                                        pcan_strength=pcan_strength,
+                                        pcan_offset=pcan_offset,
+                                        gain_bits=gain_bits,
+                                        enable_log=enable_log,
+                                        scale_shift=scale_shift,
+                                        left_context=left_context,
+                                        right_context=right_context,
+                                        frame_stride=frame_stride,
+                                        zero_padding=zero_padding,
+                                        out_scale=out_scale,
+                                        out_type=out_type, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("sample_rate", _op._get_attr_int("sample_rate"), "window_size",
+              _op._get_attr_int("window_size"), "window_step",
+              _op._get_attr_int("window_step"), "num_channels",
+              _op._get_attr_int("num_channels"), "upper_band_limit",
+              _op.get_attr("upper_band_limit"), "lower_band_limit",
+              _op.get_attr("lower_band_limit"), "smoothing_bits",
+              _op._get_attr_int("smoothing_bits"), "even_smoothing",
+              _op.get_attr("even_smoothing"), "odd_smoothing",
+              _op.get_attr("odd_smoothing"), "min_signal_remaining",
+              _op.get_attr("min_signal_remaining"), "enable_pcan",
+              _op._get_attr_bool("enable_pcan"), "pcan_strength",
+              _op.get_attr("pcan_strength"), "pcan_offset",
+              _op.get_attr("pcan_offset"), "gain_bits",
+              _op._get_attr_int("gain_bits"), "enable_log",
+              _op._get_attr_bool("enable_log"), "scale_shift",
+              _op._get_attr_int("scale_shift"), "left_context",
+              _op._get_attr_int("left_context"), "right_context",
+              _op._get_attr_int("right_context"), "frame_stride",
+              _op._get_attr_int("frame_stride"), "zero_padding",
+              _op._get_attr_bool("zero_padding"), "out_scale",
+              _op._get_attr_int("out_scale"), "out_type",
+              _op._get_attr_type("out_type"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "AudioMicrofrontend", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+AudioMicrofrontend = tf_export("raw_ops.AudioMicrofrontend")(_ops.to_raw_op(audio_microfrontend))
+_dispatcher_for_audio_microfrontend = audio_microfrontend._tf_type_based_dispatcher.Dispatch
+
+
+def audio_microfrontend_eager_fallback(audio: Annotated[Any, _atypes.Int16], sample_rate: int, window_size: int, window_step: int, num_channels: int, upper_band_limit: float, lower_band_limit: float, smoothing_bits: int, even_smoothing: float, odd_smoothing: float, min_signal_remaining: float, enable_pcan: bool, pcan_strength: float, pcan_offset: float, gain_bits: int, enable_log: bool, scale_shift: int, left_context: int, right_context: int, frame_stride: int, zero_padding: bool, out_scale: int, out_type: TV_AudioMicrofrontend_out_type, name, ctx) -> Annotated[Any, TV_AudioMicrofrontend_out_type]:
+  if sample_rate is None:
+    sample_rate = 16000
+  sample_rate = _execute.make_int(sample_rate, "sample_rate")
+  if window_size is None:
+    window_size = 25
+  window_size = _execute.make_int(window_size, "window_size")
+  if window_step is None:
+    window_step = 10
+  window_step = _execute.make_int(window_step, "window_step")
+  if num_channels is None:
+    num_channels = 32
+  num_channels = _execute.make_int(num_channels, "num_channels")
+  if upper_band_limit is None:
+    upper_band_limit = 7500
+  upper_band_limit = _execute.make_float(upper_band_limit, "upper_band_limit")
+  if lower_band_limit is None:
+    lower_band_limit = 125
+  lower_band_limit = _execute.make_float(lower_band_limit, "lower_band_limit")
+  if smoothing_bits is None:
+    smoothing_bits = 10
+  smoothing_bits = _execute.make_int(smoothing_bits, "smoothing_bits")
+  if even_smoothing is None:
+    even_smoothing = 0.025
+  even_smoothing = _execute.make_float(even_smoothing, "even_smoothing")
+  if odd_smoothing is None:
+    odd_smoothing = 0.06
+  odd_smoothing = _execute.make_float(odd_smoothing, "odd_smoothing")
+  if min_signal_remaining is None:
+    min_signal_remaining = 0.05
+  min_signal_remaining = _execute.make_float(min_signal_remaining, "min_signal_remaining")
+  if enable_pcan is None:
+    enable_pcan = False
+  enable_pcan = _execute.make_bool(enable_pcan, "enable_pcan")
+  if pcan_strength is None:
+    pcan_strength = 0.95
+  pcan_strength = _execute.make_float(pcan_strength, "pcan_strength")
+  if pcan_offset is None:
+    pcan_offset = 80
+  pcan_offset = _execute.make_float(pcan_offset, "pcan_offset")
+  if gain_bits is None:
+    gain_bits = 21
+  gain_bits = _execute.make_int(gain_bits, "gain_bits")
+  if enable_log is None:
+    enable_log = True
+  enable_log = _execute.make_bool(enable_log, "enable_log")
+  if scale_shift is None:
+    scale_shift = 6
+  scale_shift = _execute.make_int(scale_shift, "scale_shift")
+  if left_context is None:
+    left_context = 0
+  left_context = _execute.make_int(left_context, "left_context")
+  if right_context is None:
+    right_context = 0
+  right_context = _execute.make_int(right_context, "right_context")
+  if frame_stride is None:
+    frame_stride = 1
+  frame_stride = _execute.make_int(frame_stride, "frame_stride")
+  if zero_padding is None:
+    zero_padding = False
+  zero_padding = _execute.make_bool(zero_padding, "zero_padding")
+  if out_scale is None:
+    out_scale = 1
+  out_scale = _execute.make_int(out_scale, "out_scale")
+  if out_type is None:
+    out_type = _dtypes.uint16
+  out_type = _execute.make_type(out_type, "out_type")
+  audio = _ops.convert_to_tensor(audio, _dtypes.int16)
+  _inputs_flat = [audio]
+  _attrs = ("sample_rate", sample_rate, "window_size", window_size,
+  "window_step", window_step, "num_channels", num_channels,
+  "upper_band_limit", upper_band_limit, "lower_band_limit", lower_band_limit,
+  "smoothing_bits", smoothing_bits, "even_smoothing", even_smoothing,
+  "odd_smoothing", odd_smoothing, "min_signal_remaining",
+  min_signal_remaining, "enable_pcan", enable_pcan, "pcan_strength",
+  pcan_strength, "pcan_offset", pcan_offset, "gain_bits", gain_bits,
+  "enable_log", enable_log, "scale_shift", scale_shift, "left_context",
+  left_context, "right_context", right_context, "frame_stride", frame_stride,
+  "zero_padding", zero_padding, "out_scale", out_scale, "out_type", out_type)
+  _result = _execute.execute(b"AudioMicrofrontend", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "AudioMicrofrontend", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/experimental/microfrontend/python/ops/audio_microfrontend_op.py

@@ -0,0 +1,110 @@
+# 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.
+# ==============================================================================
+"""AudioMicrofrontend Op creates filterbanks from audio data."""
+
+from tensorflow.lite.experimental.microfrontend.ops import gen_audio_microfrontend_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import load_library
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.platform import resource_loader
+
+_audio_microfrontend_op = load_library.load_op_library(
+    resource_loader.get_path_to_datafile("_audio_microfrontend_op.so"))
+
+
+def audio_microfrontend(audio,
+                        sample_rate=16000,
+                        window_size=25,
+                        window_step=10,
+                        num_channels=32,
+                        upper_band_limit=7500.0,
+                        lower_band_limit=125.0,
+                        smoothing_bits=10,
+                        even_smoothing=0.025,
+                        odd_smoothing=0.06,
+                        min_signal_remaining=0.05,
+                        enable_pcan=True,
+                        pcan_strength=0.95,
+                        pcan_offset=80.0,
+                        gain_bits=21,
+                        enable_log=True,
+                        scale_shift=6,
+                        left_context=0,
+                        right_context=0,
+                        frame_stride=1,
+                        zero_padding=False,
+                        out_scale=1,
+                        out_type=dtypes.uint16):
+  """Audio Microfrontend Op.
+
+  This Op converts a sequence of audio data into one or more
+  feature vectors containing filterbanks of the input. The
+  conversion process uses a lightweight library to perform:
+
+  1. A slicing window function
+  2. Short-time FFTs
+  3. Filterbank calculations
+  4. Noise reduction
+  5. PCAN Auto Gain Control
+  6. Logarithmic scaling
+
+  Args:
+    audio: 1D Tensor, int16 audio data in temporal ordering.
+    sample_rate: Integer, the sample rate of the audio in Hz.
+    window_size: Integer, length of desired time frames in ms.
+    window_step: Integer, length of step size for the next frame in ms.
+    num_channels: Integer, the number of filterbank channels to use.
+    upper_band_limit: Float, the highest frequency included in the filterbanks.
+    lower_band_limit: Float, the lowest frequency included in the filterbanks.
+    smoothing_bits: Int, scale up signal by 2^(smoothing_bits) before reduction.
+    even_smoothing: Float, smoothing coefficient for even-numbered channels.
+    odd_smoothing: Float, smoothing coefficient for odd-numbered channels.
+    min_signal_remaining: Float, fraction of signal to preserve in smoothing.
+    enable_pcan: Bool, enable PCAN auto gain control.
+    pcan_strength: Float, gain normalization exponent.
+    pcan_offset: Float, positive value added in the normalization denominator.
+    gain_bits: Int, number of fractional bits in the gain.
+    enable_log: Bool, enable logarithmic scaling of filterbanks.
+    scale_shift: Integer, scale filterbanks by 2^(scale_shift).
+    left_context: Integer, number of preceding frames to attach to each frame.
+    right_context: Integer, number of preceding frames to attach to each frame.
+    frame_stride: Integer, M frames to skip over, where output[n] = frame[n*M].
+    zero_padding: Bool, if left/right context is out-of-bounds, attach frame of
+      zeroes. Otherwise, frame[0] or frame[size-1] will be copied.
+    out_scale: Integer, divide all filterbanks by this number.
+    out_type: DType, type of the output Tensor, defaults to UINT16.
+
+  Returns:
+    filterbanks: 2D Tensor, each row is a time frame, each column is a channel.
+
+  Raises:
+    ValueError: If the audio tensor is not explicitly a vector.
+  """
+  audio_shape = audio.shape
+  if audio_shape.ndims is None:
+    raise ValueError("Input to `AudioMicrofrontend` should have known rank.")
+  if len(audio_shape) > 1:
+    audio = array_ops.reshape(audio, [-1])
+
+  return gen_audio_microfrontend_op.audio_microfrontend(
+      audio, sample_rate, window_size, window_step, num_channels,
+      upper_band_limit, lower_band_limit, smoothing_bits, even_smoothing,
+      odd_smoothing, min_signal_remaining, enable_pcan, pcan_strength,
+      pcan_offset, gain_bits, enable_log, scale_shift, left_context,
+      right_context, frame_stride, zero_padding, out_scale, out_type)
+
+
+ops.NotDifferentiable("AudioMicrofrontend")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/analyzer.py

@@ -0,0 +1,105 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""This tool analyzes a TensorFlow Lite graph."""
+
+import os
+
+# pylint: disable=g-import-not-at-top
+if not os.path.splitext(__file__)[0].endswith(
+    os.path.join("tflite_runtime", "analyzer")):
+  # This file is part of tensorflow package.
+  from tensorflow.lite.python import wrap_toco
+  from tensorflow.lite.python.analyzer_wrapper import _pywrap_analyzer_wrapper as _analyzer_wrapper
+  from tensorflow.python.util.tf_export import tf_export as _tf_export
+else:
+  # This file is part of tflite_runtime package.
+  from tflite_runtime import _pywrap_analyzer_wrapper as _analyzer_wrapper
+
+  def _tf_export(*x, **kwargs):
+    del x, kwargs
+    return lambda x: x
+
+
+@_tf_export("lite.experimental.Analyzer")
+class ModelAnalyzer():
+  """Provides a collection of TFLite model analyzer tools.
+
+  Example:
+
+  ```python
+  model = tf.keras.applications.MobileNetV3Large()
+  fb_model = tf.lite.TFLiteConverterV2.from_keras_model(model).convert()
+  tf.lite.experimental.Analyzer.analyze(model_content=fb_model)
+  # === TFLite ModelAnalyzer ===
+  #
+  # Your TFLite model has ‘1’ subgraph(s). In the subgraph description below,
+  # T# represents the Tensor numbers. For example, in Subgraph#0, the MUL op
+  # takes tensor #0 and tensor #19 as input and produces tensor #136 as output.
+  #
+  # Subgraph#0 main(T#0) -> [T#263]
+  #   Op#0 MUL(T#0, T#19) -> [T#136]
+  #   Op#1 ADD(T#136, T#18) -> [T#137]
+  #   Op#2 CONV_2D(T#137, T#44, T#93) -> [T#138]
+  #   Op#3 HARD_SWISH(T#138) -> [T#139]
+  #   Op#4 DEPTHWISE_CONV_2D(T#139, T#94, T#24) -> [T#140]
+  #   ...
+  ```
+
+  WARNING: Experimental interface, subject to change.
+  """
+
+  @staticmethod
+  def analyze(model_path=None,
+              model_content=None,
+              gpu_compatibility=False,
+              **kwargs):
+    """Analyzes the given tflite_model with dumping model structure.
+
+    This tool provides a way to understand users' TFLite flatbuffer model by
+    dumping internal graph structure. It also provides additional features
+    like checking GPU delegate compatibility.
+
+    WARNING: Experimental interface, subject to change.
+             The output format is not guaranteed to stay stable, so don't
+             write scripts to this.
+
+    Args:
+      model_path: TFLite flatbuffer model path.
+      model_content: TFLite flatbuffer model object.
+      gpu_compatibility: Whether to check GPU delegate compatibility.
+      **kwargs: Experimental keyword arguments to analyze API.
+
+    Returns:
+      Print analyzed report via console output.
+    """
+    if not model_path and not model_content:
+      raise ValueError("neither `model_path` nor `model_content` is provided")
+    if model_path:
+      print(f"=== {model_path} ===\n")
+      tflite_model = model_path
+      input_is_filepath = True
+    else:
+      print("=== TFLite ModelAnalyzer ===\n")
+      tflite_model = model_content
+      input_is_filepath = False
+
+    if kwargs.get("experimental_use_mlir", False):
+      print(
+          wrap_toco.wrapped_flat_buffer_file_to_mlir(tflite_model,
+                                                     input_is_filepath))
+    else:
+      print(
+          _analyzer_wrapper.ModelAnalyzer(tflite_model, input_is_filepath,
+                                          gpu_compatibility))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/analyzer_wrapper/_pywrap_analyzer_wrapper.pyi

@@ -0,0 +1,16 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+def ModelAnalyzer(arg0: str, arg1: bool, arg2: bool) -> str: ...

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/authoring/authoring.py

@@ -0,0 +1,303 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""TensorFlow Authoring tool package for TFLite compatibility.
+
+WARNING: The package is experimental and subject to change.
+
+This package provides a way to check TFLite compatibility at model authoring
+time.
+
+Example:
+    @tf.lite.experimental.authoring.compatible
+    @tf.function(input_signature=[
+        tf.TensorSpec(shape=[None], dtype=tf.float32)
+    ])
+    def f(x):
+      return tf.cosh(x)
+
+    result = f(tf.constant([0.0]))
+
+    > COMPATIBILITY WARNING: op 'tf.Cosh' require(s) "Select TF Ops" for model
+    > conversion for TensorFlow Lite.
+    > Op: tf.Cosh
+    >   - tensorflow/python/framework/op_def_library.py:xxx
+    >   - tensorflow/python/ops/gen_math_ops.py:xxx
+    >   - simple_authoring.py:xxx
+"""
+import functools
+
+
+# pylint: disable=g-import-not-at-top
+from tensorflow.lite.python import convert
+from tensorflow.lite.python import lite
+from tensorflow.lite.python.metrics import converter_error_data_pb2
+from tensorflow.python.util.tf_export import tf_export as _tf_export
+
+
+_CUSTOM_OPS_HDR = "Custom ops: "
+_TF_OPS_HDR = "TF Select ops: "
+_AUTHORING_ERROR_HDR = "COMPATIBILITY ERROR"
+_AUTHORING_WARNING_HDR = "COMPATIBILITY WARNING"
+_FUNC_GRAPH_SRC_PATH = "tensorflow/python/framework/func_graph.py"
+
+
+class CompatibilityError(Exception):
+  """Raised when an error occurs with TFLite compatibility."""
+  pass
+
+
+class _Compatible:
+  """A decorator class to check TFLite compatibility created by `lite.experimental.authoring.compatible`."""
+
+  def __init__(self,
+               target,
+               converter_target_spec=None,
+               converter_allow_custom_ops=None,
+               raise_exception=False):
+    """Initialize the decorator object.
+
+    Here is the description of the object variables.
+    - _func     : decorated function.
+    - _obj_func : for class object, we need to use this object to provide `self`
+                  instance as 1 first argument.
+    - _verified : whether the compatibility is checked or not.
+
+    Args:
+      target: decorated function.
+      converter_target_spec : target_spec of TFLite converter parameter.
+      converter_allow_custom_ops : allow_custom_ops of TFLite converter
+          parameter.
+      raise_exception : to raise an exception on compatibility issues.
+          User need to use get_compatibility_log() to check details.
+    """
+    functools.update_wrapper(self, target)
+    self._func = target
+    self._obj_func = None
+    self._verified = False
+    self._log_messages = []
+    self._raise_exception = raise_exception
+    self._converter_target_spec = converter_target_spec
+    self._converter_allow_custom_ops = converter_allow_custom_ops
+
+  def __get__(self, instance, cls):
+    """A Python descriptor interface."""
+    self._obj_func = self._func.__get__(instance, cls)
+    return self
+
+  def _get_func(self):
+    """Returns decorated function object.
+
+    For a class method, use self._obj_func to provide `self` instance.
+    """
+    if self._obj_func is not None:
+      return self._obj_func
+    else:
+      return self._func
+
+  def __call__(self, *args, **kwargs):  # pylint: disable=g-doc-args
+    """Calls decorated function object.
+
+    Also verifies if the function is compatible with TFLite.
+
+    Returns:
+      A execution result of the decorated function.
+    """
+
+    if not self._verified:
+      model = self._get_func()
+      concrete_func = model.get_concrete_function(*args, **kwargs)
+      converter = lite.TFLiteConverterV2.from_concrete_functions(
+          [concrete_func], model)
+      # Set provided converter parameters
+      if self._converter_target_spec is not None:
+        converter.target_spec = self._converter_target_spec
+      if self._converter_allow_custom_ops is not None:
+        converter.allow_custom_ops = self._converter_allow_custom_ops
+      try:
+        converter.convert()
+      except convert.ConverterError as err:
+        self._decode_error(err)
+      finally:
+        self._verified = True
+
+    return self._get_func()(*args, **kwargs)
+
+  def get_concrete_function(self, *args, **kwargs):
+    """Returns a concrete function of the decorated function."""
+    return self._get_func().get_concrete_function(*args, **kwargs)
+
+  def _get_location_string(self, location):
+    """Dump location of ConveterError.errors.location."""
+    callstack = []
+    for single_call in reversed(location.call):
+      if (location.type ==
+          converter_error_data_pb2.ConverterErrorData.CALLSITELOC):
+        callstack.append(
+            f"  - {single_call.source.filename}:{single_call.source.line}")
+      else:
+        callstack.append(str(single_call))
+    callstack_dump = "\n".join(callstack)
+    return callstack_dump
+
+  def _dump_error_details(self, ops, locations):
+    """Dump the list of ops and locations."""
+    for i in range(0, len(ops)):
+      callstack_dump = self._get_location_string(locations[i])
+      err_string = f"Op: {ops[i]}\n{callstack_dump}\n"
+      self._log(err_string)
+
+  def _decode_error_legacy(self, err):
+    """Parses the given legacy ConverterError for OSS."""
+    for line in str(err).splitlines():
+      # Check custom op usage error.
+      if line.startswith(_CUSTOM_OPS_HDR):
+        custom_ops = line[len(_CUSTOM_OPS_HDR):]
+        err_string = (
+            f"{_AUTHORING_ERROR_HDR}: op '{custom_ops}' is(are) not natively "
+            "supported by TensorFlow Lite. You need to provide a custom "
+            "operator. https://www.tensorflow.org/lite/guide/ops_custom")
+        self._log(err_string)
+      # Check TensorFlow op usage error.
+      elif line.startswith(_TF_OPS_HDR):
+        tf_ops = line[len(_TF_OPS_HDR):]
+        err_string = (
+            f"{_AUTHORING_WARNING_HDR}: op '{tf_ops}' require(s) \"Select TF "
+            "Ops\" for model conversion for TensorFlow Lite. "
+            "https://www.tensorflow.org/lite/guide/ops_select")
+        self._log(err_string)
+
+  def _decode_converter_error(self, err):
+    """Parses the given ConverterError which has detailed error information."""
+    custom_ops = []
+    custom_ops_location = []
+    tf_ops = []
+    tf_ops_location = []
+    gpu_not_compatible_ops = []
+    for err in err.errors:
+      # Check custom op usage error.
+      if err.error_code == converter_error_data_pb2.ConverterErrorData.ERROR_NEEDS_CUSTOM_OPS:
+        custom_ops.append(err.operator.name)
+        custom_ops_location.append(err.location)
+      # Check TensorFlow op usage error.
+      elif err.error_code == converter_error_data_pb2.ConverterErrorData.ERROR_NEEDS_FLEX_OPS:
+        tf_ops.append(err.operator.name)
+        tf_ops_location.append(err.location)
+      # Check GPU delegate compatibility error.
+      elif err.error_code == converter_error_data_pb2.ConverterErrorData.ERROR_GPU_NOT_COMPATIBLE:
+        gpu_not_compatible_ops.append(err.operator.name)
+        # Log the first line of ConveterError.errors.error_message only
+        # since the seond line is "Error code: xxxx"
+        self._log(err.error_message.splitlines()[0])
+        self._log(self._get_location_string(err.location) + "\n")
+      else:
+        # Log other errors.
+        self._log(f"{_AUTHORING_ERROR_HDR}: {err.error_message}")
+        self._log(self._get_location_string(err.location) + "\n")
+
+    if custom_ops:
+      custom_ops_str = ", ".join(sorted(custom_ops))
+      err_string = (
+          f"{_AUTHORING_ERROR_HDR}: op '{custom_ops_str}' is(are) not natively "
+          "supported by TensorFlow Lite. You need to provide a custom "
+          "operator. https://www.tensorflow.org/lite/guide/ops_custom")
+      self._log(err_string)
+      self._dump_error_details(custom_ops, custom_ops_location)
+
+    if tf_ops:
+      tf_ops_str = ", ".join(sorted(tf_ops))
+      err_string = (
+          f"{_AUTHORING_WARNING_HDR}: op '{tf_ops_str}' require(s) \"Select TF"
+          " Ops\" for model conversion for TensorFlow Lite. "
+          "https://www.tensorflow.org/lite/guide/ops_select")
+      self._log(err_string)
+      self._dump_error_details(tf_ops, tf_ops_location)
+
+    if gpu_not_compatible_ops:
+      not_compatible_ops_str = ", ".join(sorted(gpu_not_compatible_ops))
+      err_string = (
+          f"{_AUTHORING_WARNING_HDR}: op '{not_compatible_ops_str}' aren't "
+          "compatible with TensorFlow Lite GPU delegate. "
+          "https://www.tensorflow.org/lite/performance/gpu")
+      self._log(err_string)
+
+  def _decode_error(self, err):
+    """Parses the given ConverterError and generates compatibility warnings."""
+    if hasattr(err, "errors"):
+      self._decode_converter_error(err)
+    else:
+      self._decode_error_legacy(err)
+
+    if self._raise_exception and self._log_messages:
+      raise CompatibilityError(f"CompatibilityException at {repr(self._func)}")
+
+  def _log(self, message):
+    """Log and print authoring warning / error message."""
+    self._log_messages.append(message)
+    print(message)
+
+  def get_compatibility_log(self):
+    """Returns list of compatibility log messages.
+
+    WARNING: This method should only be used for unit tests.
+
+    Returns:
+      The list of log messages by the recent compatibility check.
+    Raises:
+      RuntimeError: when the compatibility was NOT checked.
+    """
+    if not self._verified:
+      raise RuntimeError("target compatibility isn't verified yet")
+    return self._log_messages
+
+
+@_tf_export("lite.experimental.authoring.compatible")
+def compatible(target=None, converter_target_spec=None, **kwargs):
+  """Wraps `tf.function` into a callable function with TFLite compatibility checking.
+
+  Example:
+
+  ```python
+  @tf.lite.experimental.authoring.compatible
+  @tf.function(input_signature=[
+      tf.TensorSpec(shape=[None], dtype=tf.float32)
+  ])
+  def f(x):
+      return tf.cosh(x)
+
+  result = f(tf.constant([0.0]))
+  # COMPATIBILITY WARNING: op 'tf.Cosh' require(s) "Select TF Ops" for model
+  # conversion for TensorFlow Lite.
+  # Op: tf.Cosh
+  #   - tensorflow/python/framework/op_def_library.py:748
+  #   - tensorflow/python/ops/gen_math_ops.py:2458
+  #   - <stdin>:6
+  ```
+
+  WARNING: Experimental interface, subject to change.
+
+  Args:
+    target: A `tf.function` to decorate.
+    converter_target_spec : target_spec of TFLite converter parameter.
+    **kwargs: The keyword arguments of the decorator class _Compatible.
+
+  Returns:
+     A callable object of `tf.lite.experimental.authoring._Compatible`.
+  """
+  if target is None:
+    def wrapper(target):
+      return _Compatible(target, converter_target_spec, **kwargs)
+    return wrapper
+  else:
+    return _Compatible(target, converter_target_spec, **kwargs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/conversion_metadata_schema_py_generated.py

@@ -0,0 +1,554 @@
+import flatbuffers
+
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ModelType(object):
+    NONE = 0
+    TF_SAVED_MODEL = 1
+    KERAS_MODEL = 2
+    TF_CONCRETE_FUNCTIONS = 3
+    TF_GRAPH_DEF = 4
+    TF_SESSION = 5
+    JAX = 6
+
+
+class ModelOptimizationMode(object):
+    PTQ_FLOAT16 = 1001
+    PTQ_DYNAMIC_RANGE = 1002
+    PTQ_FULL_INTEGER = 1003
+    PTQ_INT16 = 1004
+    QUANTIZATION_AWARE_TRAINING = 2000
+    RANDOM_SPARSITY = 3001
+    BLOCK_SPARSITY = 3002
+    STRUCTURED_SPARSITY = 3003
+
+
+class Environment(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Environment()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEnvironment(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Environment
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Environment
+    def TensorflowVersion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Environment
+    def ApiVersion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Environment
+    def ModelType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def EnvironmentStart(builder):
+    builder.StartObject(3)
+
+def EnvironmentAddTensorflowVersion(builder, tensorflowVersion):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensorflowVersion), 0)
+
+def EnvironmentAddApiVersion(builder, apiVersion):
+    builder.PrependUint32Slot(1, apiVersion, 0)
+
+def EnvironmentAddModelType(builder, modelType):
+    builder.PrependInt32Slot(2, modelType, 0)
+
+def EnvironmentEnd(builder):
+    return builder.EndObject()
+
+
+
+class EnvironmentT(object):
+
+    # EnvironmentT
+    def __init__(self):
+        self.tensorflowVersion = None  # type: str
+        self.apiVersion = 0  # type: int
+        self.modelType = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        environment = Environment()
+        environment.Init(buf, pos)
+        return cls.InitFromObj(environment)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, environment):
+        x = EnvironmentT()
+        x._UnPack(environment)
+        return x
+
+    # EnvironmentT
+    def _UnPack(self, environment):
+        if environment is None:
+            return
+        self.tensorflowVersion = environment.TensorflowVersion()
+        self.apiVersion = environment.ApiVersion()
+        self.modelType = environment.ModelType()
+
+    # EnvironmentT
+    def Pack(self, builder):
+        if self.tensorflowVersion is not None:
+            tensorflowVersion = builder.CreateString(self.tensorflowVersion)
+        EnvironmentStart(builder)
+        if self.tensorflowVersion is not None:
+            EnvironmentAddTensorflowVersion(builder, tensorflowVersion)
+        EnvironmentAddApiVersion(builder, self.apiVersion)
+        EnvironmentAddModelType(builder, self.modelType)
+        environment = EnvironmentEnd(builder)
+        return environment
+
+
+class SparsityBlockSize(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SparsityBlockSize()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSparsityBlockSize(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SparsityBlockSize
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SparsityBlockSize
+    def Values(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # SparsityBlockSize
+    def ValuesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o)
+        return 0
+
+    # SparsityBlockSize
+    def ValuesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SparsityBlockSize
+    def ValuesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def SparsityBlockSizeStart(builder):
+    builder.StartObject(1)
+
+def SparsityBlockSizeAddValues(builder, values):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+
+def SparsityBlockSizeStartValuesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def SparsityBlockSizeEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class SparsityBlockSizeT(object):
+
+    # SparsityBlockSizeT
+    def __init__(self):
+        self.values = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        sparsityBlockSize = SparsityBlockSize()
+        sparsityBlockSize.Init(buf, pos)
+        return cls.InitFromObj(sparsityBlockSize)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, sparsityBlockSize):
+        x = SparsityBlockSizeT()
+        x._UnPack(sparsityBlockSize)
+        return x
+
+    # SparsityBlockSizeT
+    def _UnPack(self, sparsityBlockSize):
+        if sparsityBlockSize is None:
+            return
+        if not sparsityBlockSize.ValuesIsNone():
+            if np is None:
+                self.values = []
+                for i in range(sparsityBlockSize.ValuesLength()):
+                    self.values.append(sparsityBlockSize.Values(i))
+            else:
+                self.values = sparsityBlockSize.ValuesAsNumpy()
+
+    # SparsityBlockSizeT
+    def Pack(self, builder):
+        if self.values is not None:
+            if np is not None and type(self.values) is np.ndarray:
+                values = builder.CreateNumpyVector(self.values)
+            else:
+                SparsityBlockSizeStartValuesVector(builder, len(self.values))
+                for i in reversed(range(len(self.values))):
+                    builder.PrependUint32(self.values[i])
+                values = builder.EndVector()
+        SparsityBlockSizeStart(builder)
+        if self.values is not None:
+            SparsityBlockSizeAddValues(builder, values)
+        sparsityBlockSize = SparsityBlockSizeEnd(builder)
+        return sparsityBlockSize
+
+
+class ConversionOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ConversionOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsConversionOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # ConversionOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ConversionOptions
+    def ModelOptimizationModes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # ConversionOptions
+    def ModelOptimizationModesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # ConversionOptions
+    def ModelOptimizationModesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ConversionOptions
+    def ModelOptimizationModesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # ConversionOptions
+    def AllowCustomOps(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # ConversionOptions
+    def EnableSelectTfOps(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # ConversionOptions
+    def ForceSelectTfOps(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # ConversionOptions
+    def SparsityBlockSizes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = SparsityBlockSize()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ConversionOptions
+    def SparsityBlockSizesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ConversionOptions
+    def SparsityBlockSizesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def ConversionOptionsStart(builder):
+    builder.StartObject(5)
+
+def ConversionOptionsAddModelOptimizationModes(builder, modelOptimizationModes):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(modelOptimizationModes), 0)
+
+def ConversionOptionsStartModelOptimizationModesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def ConversionOptionsAddAllowCustomOps(builder, allowCustomOps):
+    builder.PrependBoolSlot(1, allowCustomOps, 0)
+
+def ConversionOptionsAddEnableSelectTfOps(builder, enableSelectTfOps):
+    builder.PrependBoolSlot(2, enableSelectTfOps, 0)
+
+def ConversionOptionsAddForceSelectTfOps(builder, forceSelectTfOps):
+    builder.PrependBoolSlot(3, forceSelectTfOps, 0)
+
+def ConversionOptionsAddSparsityBlockSizes(builder, sparsityBlockSizes):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(sparsityBlockSizes), 0)
+
+def ConversionOptionsStartSparsityBlockSizesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def ConversionOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class ConversionOptionsT(object):
+
+    # ConversionOptionsT
+    def __init__(self):
+        self.modelOptimizationModes = None  # type: List[int]
+        self.allowCustomOps = False  # type: bool
+        self.enableSelectTfOps = False  # type: bool
+        self.forceSelectTfOps = False  # type: bool
+        self.sparsityBlockSizes = None  # type: List[SparsityBlockSizeT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        conversionOptions = ConversionOptions()
+        conversionOptions.Init(buf, pos)
+        return cls.InitFromObj(conversionOptions)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, conversionOptions):
+        x = ConversionOptionsT()
+        x._UnPack(conversionOptions)
+        return x
+
+    # ConversionOptionsT
+    def _UnPack(self, conversionOptions):
+        if conversionOptions is None:
+            return
+        if not conversionOptions.ModelOptimizationModesIsNone():
+            if np is None:
+                self.modelOptimizationModes = []
+                for i in range(conversionOptions.ModelOptimizationModesLength()):
+                    self.modelOptimizationModes.append(conversionOptions.ModelOptimizationModes(i))
+            else:
+                self.modelOptimizationModes = conversionOptions.ModelOptimizationModesAsNumpy()
+        self.allowCustomOps = conversionOptions.AllowCustomOps()
+        self.enableSelectTfOps = conversionOptions.EnableSelectTfOps()
+        self.forceSelectTfOps = conversionOptions.ForceSelectTfOps()
+        if not conversionOptions.SparsityBlockSizesIsNone():
+            self.sparsityBlockSizes = []
+            for i in range(conversionOptions.SparsityBlockSizesLength()):
+                if conversionOptions.SparsityBlockSizes(i) is None:
+                    self.sparsityBlockSizes.append(None)
+                else:
+                    sparsityBlockSize_ = SparsityBlockSizeT.InitFromObj(conversionOptions.SparsityBlockSizes(i))
+                    self.sparsityBlockSizes.append(sparsityBlockSize_)
+
+    # ConversionOptionsT
+    def Pack(self, builder):
+        if self.modelOptimizationModes is not None:
+            if np is not None and type(self.modelOptimizationModes) is np.ndarray:
+                modelOptimizationModes = builder.CreateNumpyVector(self.modelOptimizationModes)
+            else:
+                ConversionOptionsStartModelOptimizationModesVector(builder, len(self.modelOptimizationModes))
+                for i in reversed(range(len(self.modelOptimizationModes))):
+                    builder.PrependInt32(self.modelOptimizationModes[i])
+                modelOptimizationModes = builder.EndVector()
+        if self.sparsityBlockSizes is not None:
+            sparsityBlockSizeslist = []
+            for i in range(len(self.sparsityBlockSizes)):
+                sparsityBlockSizeslist.append(self.sparsityBlockSizes[i].Pack(builder))
+            ConversionOptionsStartSparsityBlockSizesVector(builder, len(self.sparsityBlockSizes))
+            for i in reversed(range(len(self.sparsityBlockSizes))):
+                builder.PrependUOffsetTRelative(sparsityBlockSizeslist[i])
+            sparsityBlockSizes = builder.EndVector()
+        ConversionOptionsStart(builder)
+        if self.modelOptimizationModes is not None:
+            ConversionOptionsAddModelOptimizationModes(builder, modelOptimizationModes)
+        ConversionOptionsAddAllowCustomOps(builder, self.allowCustomOps)
+        ConversionOptionsAddEnableSelectTfOps(builder, self.enableSelectTfOps)
+        ConversionOptionsAddForceSelectTfOps(builder, self.forceSelectTfOps)
+        if self.sparsityBlockSizes is not None:
+            ConversionOptionsAddSparsityBlockSizes(builder, sparsityBlockSizes)
+        conversionOptions = ConversionOptionsEnd(builder)
+        return conversionOptions
+
+
+class ConversionMetadata(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ConversionMetadata()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsConversionMetadata(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # ConversionMetadata
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ConversionMetadata
+    def Environment(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = Environment()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ConversionMetadata
+    def Options(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = ConversionOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ConversionMetadataStart(builder):
+    builder.StartObject(2)
+
+def ConversionMetadataAddEnvironment(builder, environment):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(environment), 0)
+
+def ConversionMetadataAddOptions(builder, options):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(options), 0)
+
+def ConversionMetadataEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class ConversionMetadataT(object):
+
+    # ConversionMetadataT
+    def __init__(self):
+        self.environment = None  # type: Optional[EnvironmentT]
+        self.options = None  # type: Optional[ConversionOptionsT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        conversionMetadata = ConversionMetadata()
+        conversionMetadata.Init(buf, pos)
+        return cls.InitFromObj(conversionMetadata)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, conversionMetadata):
+        x = ConversionMetadataT()
+        x._UnPack(conversionMetadata)
+        return x
+
+    # ConversionMetadataT
+    def _UnPack(self, conversionMetadata):
+        if conversionMetadata is None:
+            return
+        if conversionMetadata.Environment() is not None:
+            self.environment = EnvironmentT.InitFromObj(conversionMetadata.Environment())
+        if conversionMetadata.Options() is not None:
+            self.options = ConversionOptionsT.InitFromObj(conversionMetadata.Options())
+
+    # ConversionMetadataT
+    def Pack(self, builder):
+        if self.environment is not None:
+            environment = self.environment.Pack(builder)
+        if self.options is not None:
+            options = self.options.Pack(builder)
+        ConversionMetadataStart(builder)
+        if self.environment is not None:
+            ConversionMetadataAddEnvironment(builder, environment)
+        if self.options is not None:
+            ConversionMetadataAddOptions(builder, options)
+        conversionMetadata = ConversionMetadataEnd(builder)
+        return conversionMetadata
+
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/convert.py

@@ -0,0 +1,1206 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Converts a frozen graph into a TFLite FlatBuffer."""
+
+import distutils.spawn
+import enum
+import hashlib
+import os as _os
+import platform as _platform
+import subprocess as _subprocess
+import tempfile as _tempfile
+from typing import Optional
+import warnings
+
+from tensorflow.compiler.mlir.quantization.stablehlo import quantization_options_pb2 as quant_opts_pb2
+from tensorflow.lite.python import lite_constants
+from tensorflow.lite.python import util
+from tensorflow.lite.python import wrap_toco
+from tensorflow.lite.python.convert_phase import Component
+from tensorflow.lite.python.convert_phase import convert_phase
+from tensorflow.lite.python.convert_phase import ConverterError
+from tensorflow.lite.python.convert_phase import SubComponent
+from tensorflow.lite.python.metrics import converter_error_data_pb2
+from tensorflow.lite.python.metrics.wrapper import metrics_wrapper as _metrics_wrapper
+from tensorflow.lite.toco import model_flags_pb2 as _model_flags_pb2
+from tensorflow.lite.toco import toco_flags_pb2 as _conversion_flags_pb2
+from tensorflow.lite.toco import types_pb2 as _types_pb2
+from tensorflow.lite.tools import flatbuffer_utils
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.platform import resource_loader as _resource_loader
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export as _tf_export
+
+
+def _is_quantized_input_stats_required(
+    conversion_flags: _conversion_flags_pb2.TocoFlags,
+) -> bool:
+  """Checks if the `quantized_input_stats` flag is required for conversion.
+
+  Args:
+    conversion_flags: A protocol buffer describing the conversion process.
+
+  Returns:
+    True, if the `inference_type` or the `inference_input_type` is a quantized
+    type and it is not post training quantization, else False.
+  """
+  quantized_inference_types = [
+      _types_pb2.QUANTIZED_UINT8,
+      _types_pb2.QUANTIZED_INT8,
+  ]
+  return (
+      conversion_flags.inference_type in quantized_inference_types
+      or conversion_flags.inference_input_type in quantized_inference_types
+  ) and not conversion_flags.post_training_quantize
+
+
+def convert_tensor_tf_type_to_tflite_type(
+    tf_type: dtypes.DType, usage: str = ""
+) -> _types_pb2.IODataType:
+  """Convert tensor type from tf type to tflite type.
+
+  Args:
+    tf_type: TensorFlow type.
+    usage: Text describing the reason for invoking this function.
+
+  Raises:
+    ValueError: If `tf_type` is unsupported.
+
+  Returns:
+    tflite_type: TFLite type. Refer to lite/toco/types.proto.
+  """
+  mapping = {
+      dtypes.float16: _types_pb2.FLOAT16,
+      dtypes.float32: _types_pb2.FLOAT,
+      dtypes.float64: _types_pb2.FLOAT64,
+      dtypes.int8: _types_pb2.INT8,
+      dtypes.int16: _types_pb2.INT16,
+      dtypes.uint16: _types_pb2.UINT16,
+      dtypes.int32: _types_pb2.INT32,
+      dtypes.int64: _types_pb2.INT64,
+      dtypes.uint8: _types_pb2.UINT8,
+      dtypes.uint32: _types_pb2.UINT32,
+      dtypes.uint64: _types_pb2.UINT64,
+      dtypes.string: _types_pb2.STRING,
+      dtypes.bool: _types_pb2.BOOL,
+      dtypes.complex64: _types_pb2.COMPLEX64,
+      dtypes.complex128: _types_pb2.COMPLEX128,
+  }
+  tflite_type = mapping.get(tf_type)
+  if tflite_type is None:
+    raise ValueError(
+        "Unsupported TensorFlow type `{0}` provided for the {1}".format(
+            tf_type, usage
+        )
+    )
+  return tflite_type
+
+
+# Only a few restricted tensor types are allowed for explicitly setting
+# inference/input/output types.
+def convert_inference_tf_type_to_tflite_type(
+    tf_type: dtypes.DType, usage: str = ""
+) -> _types_pb2.IODataType:
+  """Convert inference type from tf type to tflite type.
+
+  Args:
+    tf_type: TensorFlow type.
+    usage: Text describing the reason for invoking this function.
+
+  Raises:
+    ValueError: If `tf_type` is unsupported.
+
+  Returns:
+    tflite_type: TFLite type. Refer to lite/toco/types.proto.
+  """
+  mapping = {
+      dtypes.float32: _types_pb2.FLOAT,
+      dtypes.uint8: _types_pb2.QUANTIZED_UINT8,
+      dtypes.int8: _types_pb2.QUANTIZED_INT8,
+      dtypes.int16: _types_pb2.QUANTIZED_INT16,
+  }
+  tflite_type = mapping.get(tf_type)
+  if tflite_type is None:
+    raise ValueError(
+        "Unsupported TensorFlow type `{0}` provided for the {1}".format(
+            tf_type, usage
+        )
+    )
+  return tflite_type
+
+
+# Find the deprecated conversion binary using the resource loader if using from
+# bazel, otherwise we are in a pip where console_scripts already has the tool.
+if lite_constants.EXPERIMENTAL_USE_TOCO_API_DIRECTLY:
+  _deprecated_conversion_binary = ""
+else:
+  _deprecated_conversion_binary = _resource_loader.get_path_to_datafile(
+      "../toco/python/toco_from_protos"
+  )
+  if not _os.path.exists(_deprecated_conversion_binary):
+    _deprecated_conversion_binary = "toco_from_protos"
+
+
+def _try_convert_to_unicode(output):
+  if output is None:
+    return ""
+
+  if isinstance(output, bytes):
+    try:
+      return output.decode("utf-8")
+    except UnicodeDecodeError:
+      pass
+  return output
+
+
+@_tf_export("lite.OpsSet")
+class OpsSet(enum.Enum):
+  """Enum class defining the sets of ops available to generate TFLite models.
+
+  WARNING: Experimental interface, subject to change.
+  """
+
+  # Convert model using TensorFlow Lite builtin ops.
+  TFLITE_BUILTINS = "TFLITE_BUILTINS"
+
+  # Convert model using TensorFlow ops. Not all TensorFlow ops are available.
+  # WARNING: Experimental interface, subject to change.
+  SELECT_TF_OPS = "SELECT_TF_OPS"
+
+  # Convert model using only TensorFlow Lite quantized int8 operations.
+  # Specifying this will throw an error for operations that do not yet have
+  # quantized implementations.
+  TFLITE_BUILTINS_INT8 = "TFLITE_BUILTINS_INT8"
+
+  # Convert model using only TensorFlow Lite operations with quantized int8
+  # weights, int16 activations and int64 bias.
+  # Specifying this will throw an error for operations that do not yet have
+  # quantized implementations.
+  # This quantization mode may be used in models for super-resolution,
+  # audio signal processing or image de-noising. It improves accuracy
+  # significantly, but only slightly increases the model size.
+  # WARNING: These ops are currently experimental and have not yet been
+  # finalized.
+  # They are only compatible with CPU execution, and have not been optimized for
+  # production.
+  EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8 = (
+      "EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8"
+  )
+
+  # Convert model using only stablehlo ops.
+  # This option can not be combined with other OpsSets.
+  # The feature is in early development.
+  # The code to execute StableHLO ops in the runtime is to be implemented
+  # and the serialization format is not stabilized yet.
+  EXPERIMENTAL_STABLEHLO_OPS = "EXPERIMENTAL_STABLEHLO_OPS"
+
+  def __str__(self):
+    return str(self.value)
+
+  @staticmethod
+  def get_options():
+    """Returns a list of OpsSet options as a list of strings."""
+    return [str(option) for option in list(OpsSet)]
+
+
+@convert_phase(Component.OPTIMIZE_TFLITE_MODEL, SubComponent.QUANTIZE)
+def mlir_quantize(
+    input_data_str,
+    disable_per_channel=False,
+    fully_quantize=False,
+    inference_type=_types_pb2.QUANTIZED_INT8,
+    input_data_type=dtypes.float32,
+    output_data_type=dtypes.float32,
+    enable_numeric_verify=False,
+    enable_whole_model_verify=False,
+    denylisted_ops=None,
+    denylisted_nodes=None,
+    enable_variable_quantization=False,
+):
+  """Quantize `input_data_str` with calibration results.
+
+  Args:
+    input_data_str: Input data in serialized form (e.g. a TFLITE model with
+      calibration results).
+    disable_per_channel: Bool indicating whether to do per-channel or per-tensor
+      quantization
+    fully_quantize: Bool indicating whether to fully quantize the model. Besides
+      model body, the input/output will be quantized as well.
+    inference_type: Data type for the activations. The default value is int8.
+    input_data_type: Data type for the inputs. The default value is float32.
+    output_data_type: Data type for the outputs. The default value is float32.
+    enable_numeric_verify: Experimental. Subject to change. Bool indicating
+      whether to add NumericVerify ops into the debug mode quantized model.
+    enable_whole_model_verify: Experimental. Subject to change. Bool indicating
+      whether to add verification for layer by layer, or on whole model. When
+      disabled (per-layer) float and quantized ops will be run from same input
+      (output of previous quantized layer). When enabled, float and quantized
+      ops will run with respective float and quantized output of previous ops.
+    denylisted_ops: Experimental. Subject to change. Set of ops to denylist.
+    denylisted_nodes: Experimental. Subject to change. Set of notes to denylist.
+    enable_variable_quantization: Experimental. Subject to change. Bool
+      indicating whether to enable quantization of the residual variables
+      remaining after the variable freezing pass.
+
+  Returns:
+    Quantized model in serialized form (e.g. a TFLITE model) with floating-point
+    inputs and outputs.
+  """
+  return wrap_toco.wrapped_experimental_mlir_quantize(
+      input_data_str,
+      disable_per_channel,
+      fully_quantize,
+      inference_type,
+      convert_tensor_tf_type_to_tflite_type(input_data_type),
+      convert_tensor_tf_type_to_tflite_type(output_data_type),
+      enable_numeric_verify,
+      enable_whole_model_verify,
+      denylisted_ops,
+      denylisted_nodes,
+      enable_variable_quantization,
+  )
+
+
+@convert_phase(Component.OPTIMIZE_TFLITE_MODEL, SubComponent.SPARSIFY)
+def mlir_sparsify(input_data_str):
+  """Sparsify `input_data_str` to encode sparse tensor with proper format.
+
+  Args:
+    input_data_str: Input data in serialized form (e.g. a TFLITE model).
+
+  Returns:
+    Sparsified model in serialized form (e.g. a TFLITE model).
+  """
+  return wrap_toco.wrapped_experimental_mlir_sparsify(input_data_str)
+
+
+def register_custom_opdefs(custom_opdefs_list):
+  """Register the given custom opdefs to the TensorFlow global op registry.
+
+  Args:
+    custom_opdefs_list: String representing the custom ops OpDefs that are
+      included in the GraphDef.
+
+  Returns:
+    True if the registration is successfully completed.
+  """
+  return wrap_toco.wrapped_register_custom_opdefs(custom_opdefs_list)
+
+
+def convert(
+    model_flags: _model_flags_pb2.ModelFlags,
+    conversion_flags: _conversion_flags_pb2.TocoFlags,
+    input_data_str: Optional[str] = None,
+    debug_info_str: Optional[str] = None,
+    enable_mlir_converter: bool = True,
+):
+  """Converts `input_data_str` to a TFLite model.
+
+  Args:
+    model_flags: Proto describing model properties, see `model_flags.proto`.
+    conversion_flags: Proto describing conversion properties, see
+      `toco/toco_flags.proto`.
+    input_data_str: Input data in serialized form (e.g. a graphdef is common, or
+      it can be hlo text or proto)
+    debug_info_str: Serialized `GraphDebugInfo` proto describing logging
+      information.
+    enable_mlir_converter: Enables MLIR-based conversion.
+
+  Returns:
+    Converted model in serialized form (e.g. a TFLITE model is common).
+  Raises:
+    ConverterError: When conversion fails in TFLiteConverter, usually due to
+      ops not being supported.
+    RuntimeError: When conversion fails, an exception is raised with the error
+      message embedded.
+  """
+  # Historically, deprecated conversion failures would trigger a crash, so we
+  # attempt to run the converter out-of-process. The current MLIR conversion
+  # pipeline surfaces errors instead, and can be safely run in-process.
+  if enable_mlir_converter or not _deprecated_conversion_binary:
+    try:
+      return wrap_toco.wrapped_toco_convert(
+          model_flags.SerializeToString(),
+          conversion_flags.SerializeToString(),
+          input_data_str,
+          debug_info_str,
+          enable_mlir_converter,
+      )
+    except Exception as e:
+      converter_error = ConverterError(str(e))
+
+      for error_data in _metrics_wrapper.retrieve_collected_errors():
+        converter_error.append_error(error_data)
+        # Seldom we encounter the case where an unsupported
+        # `StatefulPartitionedCallOp` is not inlined and remains in the final
+        # IR. If this occurs we can set `guarantee_all_funcs_one_use` and retry.
+        # This makes the converter copy functions definitions called by
+        # multiple StatefulPartitionedCall, thus allowing them to be properly
+        # inlined.
+        if (
+            error_data.error_code
+            == converter_error_data_pb2.ConverterErrorData.ERROR_STATEFUL_PARTITIONED_CALL_IN_FINAL_IR
+            and not conversion_flags.guarantee_all_funcs_one_use
+        ):
+          conversion_flags.guarantee_all_funcs_one_use = True
+          return convert(
+              model_flags,
+              conversion_flags,
+              input_data_str,
+              debug_info_str,
+              enable_mlir_converter,
+          )
+      raise converter_error
+
+  return _run_deprecated_conversion_binary(
+      model_flags.SerializeToString(),
+      conversion_flags.SerializeToString(),
+      input_data_str,
+      debug_info_str,
+  )
+
+
+@convert_phase(
+    Component.CONVERT_TF_TO_TFLITE_MODEL,
+    SubComponent.CONVERT_GRAPHDEF_USING_DEPRECATED_CONVERTER,
+)
+def _run_deprecated_conversion_binary(
+    model_flags_str, conversion_flags_str, input_data_str, debug_info_str=None
+):
+  """Convert `input_data_str` using deprecated conversion binary.
+
+  Args:
+    model_flags_str: Serialized proto describing model properties, see
+      `model_flags.proto`.
+    conversion_flags_str: Serialized proto describing TFLite converter
+      properties, see `toco/toco_flags.proto`.
+    input_data_str: Input data in serialized form (e.g. a graphdef is common)
+    debug_info_str: Serialized `GraphDebugInfo` proto describing logging
+      information. (default None)
+
+  Returns:
+    Converted model in serialized form (e.g. a TFLITE model is common).
+  Raises:
+    ConverterError: When cannot find the deprecated conversion binary.
+    RuntimeError: When conversion fails, an exception is raised with the error
+      message embedded.
+  """
+  if distutils.spawn.find_executable(_deprecated_conversion_binary) is None:
+    raise ConverterError("""Could not find `toco_from_protos` binary, make sure
+your virtualenv bin directory or pip local bin directory is in your path.
+In particular, if you have installed TensorFlow with --user, make sure you
+add the install directory to your path.
+
+For example:
+Linux: export PATH=$PATH:~/.local/bin/
+Mac: export PATH=$PATH:~/Library/Python/<version#>/bin
+
+Alternative, use virtualenv.""")
+  # Windows and TemporaryFile are not that useful together,
+  # since you cannot have two readers/writers. So we have to
+  # make the temporaries and close and delete them explicitly.
+  conversion_filename: str = None
+  model_filename: str = None
+  input_filename: str = None
+  output_filename: str = None
+  try:
+    # Build all input files
+    with _tempfile.NamedTemporaryFile(
+        delete=False
+    ) as fp_conversion, _tempfile.NamedTemporaryFile(
+        delete=False
+    ) as fp_model, _tempfile.NamedTemporaryFile(
+        delete=False
+    ) as fp_input, _tempfile.NamedTemporaryFile(
+        delete=False
+    ) as fp_debug:
+      conversion_filename = fp_conversion.name
+      input_filename = fp_input.name
+      model_filename = fp_model.name
+      debug_filename = fp_debug.name
+
+      fp_model.write(model_flags_str)
+      fp_conversion.write(conversion_flags_str)
+      fp_input.write(input_data_str)
+      debug_info_str = debug_info_str if debug_info_str else ""
+      # if debug_info_str contains a "string value", then the call to
+      # fp_debug.write(debug_info_str) will fail with the following error
+      #
+      # TypeError: a bytes-like object is required, not 'str'
+      #
+      # Some of the subtests within the "convert_test" unit-test fail
+      # with the error shown above. So watch out for that scenario and
+      # convert debug_info_str to bytes where needed
+      if not isinstance(debug_info_str, bytes):
+        fp_debug.write(debug_info_str.encode("utf-8"))
+      else:
+        fp_debug.write(debug_info_str)
+
+    # Reserve an output file
+    with _tempfile.NamedTemporaryFile(delete=False) as fp:
+      output_filename = fp.name
+
+    # Run
+    cmd = [
+        _deprecated_conversion_binary,
+        model_filename,
+        conversion_filename,
+        input_filename,
+        output_filename,
+        "--debug_proto_file={}".format(debug_filename),
+    ]
+    cmdline = " ".join(cmd)
+    is_windows = _platform.system() == "Windows"
+    proc = _subprocess.Popen(
+        cmdline,
+        shell=True,
+        stdout=_subprocess.PIPE,
+        stderr=_subprocess.STDOUT,
+        close_fds=not is_windows,
+    )
+    stdout, stderr = proc.communicate()
+    exitcode = proc.returncode
+    if exitcode == 0:
+      with open(output_filename, "rb") as fp:
+        return fp.read()
+    else:
+      stdout = _try_convert_to_unicode(stdout)
+      stderr = _try_convert_to_unicode(stderr)
+      raise ConverterError("See console for info.\n%s\n%s\n" % (stdout, stderr))
+  finally:
+    # Must manually cleanup files.
+    for filename in [
+        conversion_filename,
+        input_filename,
+        model_filename,
+        output_filename,
+    ]:
+      try:
+        _os.unlink(filename)
+      except (OSError, TypeError):
+        pass
+
+
+def build_model_flags(
+    change_concat_input_ranges=False,
+    allow_nonexistent_arrays=False,
+    saved_model_dir=None,
+    saved_model_version=0,
+    saved_model_tags=None,
+    saved_model_exported_names=None,
+    **_
+):
+  """Builds the model flags object from params.
+
+  Args:
+    change_concat_input_ranges: Boolean to change behavior of min/max ranges for
+      inputs and outputs of the concat operator for quantized models. Changes
+      the ranges of concat operator overlap when true. (default False)
+    allow_nonexistent_arrays: Allow specifying array names that don't exist or
+      are unused in the final graph. (default False)
+    saved_model_dir: Filepath of the saved model to be converted. This value
+      will be non-empty only when the saved model import path will be used.
+      Otherwises, the graph def-based conversion will be processed.
+    saved_model_version: SavedModel file format version of The saved model file
+      to be converted. This value will be set only when the SavedModel import
+      path will be used.
+    saved_model_tags: Set of string saved model tags, formatted in the
+      comma-separated value. This value will be set only when the SavedModel
+      import path will be used.
+    saved_model_exported_names: Names to be exported (default: export all) when
+      the saved model import path is on. This value will be set only when the
+      SavedModel import path will be used.
+
+  Returns:
+    model_flags: protocol buffer describing the model.
+  """
+  model_flags = _model_flags_pb2.ModelFlags()
+  model_flags.change_concat_input_ranges = change_concat_input_ranges
+  model_flags.allow_nonexistent_arrays = allow_nonexistent_arrays
+  if saved_model_dir:
+    model_flags.saved_model_dir = saved_model_dir
+  model_flags.saved_model_version = saved_model_version
+  if saved_model_tags:
+    model_flags.saved_model_tags.extend(saved_model_tags)
+  if saved_model_exported_names:
+    model_flags.saved_model_exported_names.extend(saved_model_exported_names)
+  return model_flags
+
+
+def build_conversion_flags(
+    inference_type=dtypes.float32,
+    inference_input_type=None,
+    input_format=lite_constants.TENSORFLOW_GRAPHDEF,
+    output_format=lite_constants.TFLITE,
+    default_ranges_stats=None,
+    drop_control_dependency=True,
+    reorder_across_fake_quant=False,
+    allow_custom_ops=False,
+    post_training_quantize=False,
+    quantize_to_float16=False,
+    dump_graphviz_dir=None,
+    dump_graphviz_video=False,
+    target_ops=None,
+    conversion_summary_dir=None,
+    select_user_tf_ops=None,
+    allow_all_select_tf_ops=False,
+    enable_tflite_resource_variables=True,
+    unfold_batchmatmul=False,
+    legalize_custom_tensor_list_ops=False,
+    lower_tensor_list_ops=True,
+    default_to_single_batch_in_tensor_list_ops=False,
+    accumulation_type=None,
+    allow_bfloat16=False,
+    unfold_large_splat_constant=False,
+    supported_backends=None,
+    disable_per_channel_quantization=False,
+    enable_mlir_dynamic_range_quantizer=False,
+    tf_quantization_mode=None,
+    disable_infer_tensor_range=False,
+    use_fake_quant_num_bits=False,
+    enable_dynamic_update_slice=False,
+    preserve_assert_op=False,
+    guarantee_all_funcs_one_use=False,
+    enable_mlir_variable_quantization=False,
+    disable_fuse_mul_and_fc=False,
+    quantization_options: Optional[quant_opts_pb2.QuantizationOptions] = None,
+    mlir_dump_dir=None,
+    mlir_dump_pass_regex=None,
+    mlir_dump_func_regex=None,
+    mlir_enable_timing=None,
+    mlir_print_ir_before=None,
+    mlir_print_ir_after=None,
+    mlir_print_ir_module_scope=None,
+    mlir_elide_elementsattrs_if_larger=None,
+    use_buffer_offset=False,
+    reduce_type_precision=False,
+    **_
+):
+  """Builds protocol buffer describing a conversion of a model.
+
+  Typically this is to convert from TensorFlow GraphDef to TFLite, in which
+  case the default `input_format` and `output_format` are sufficient.
+
+  Args:
+    inference_type: Data type of numeric arrays, excluding the input layer.
+      (default tf.float32, must be in {tf.float32, tf.int8, tf.uint8})
+    inference_input_type: Data type of the numeric arrays in the input layer. If
+      `inference_input_type` is in {tf.int8, tf.uint8}, then
+      `quantized_input_stats` must be provided. (default is the value assigned
+      to `inference_type`, must be in {tf.float32, tf.int8, tf.uint8})
+    input_format: Type of data to read. (default TENSORFLOW_GRAPHDEF, must be in
+      {TENSORFLOW_GRAPHDEF})
+    output_format: Output file format. (default TFLITE, must be in {TFLITE,
+      GRAPHVIZ_DOT})
+    default_ranges_stats: Tuple of integers representing (min, max) range values
+      for all arrays without a specified range. Intended for experimenting with
+      quantization via "dummy quantization". (default None)
+    drop_control_dependency: Boolean indicating whether to drop control
+      dependencies silently. This is due to TFLite not supporting control
+      dependencies. (default True)
+    reorder_across_fake_quant: Boolean indicating whether to reorder FakeQuant
+      nodes in unexpected locations. Used when the location of the FakeQuant
+      nodes is preventing graph transformations necessary to convert the graph.
+      Results in a graph that differs from the quantized training graph,
+      potentially causing differing arithmetic behavior. (default False)
+    allow_custom_ops: Boolean indicating whether to allow custom operations.
+      When false any unknown operation is an error. When true, custom ops are
+      created for any op that is unknown. The developer will need to provide
+      these to the TensorFlow Lite runtime with a custom resolver. (default
+      False)
+    post_training_quantize: Boolean indicating whether to quantize the weights
+      of the converted float model. Model size will be reduced and there will be
+      latency improvements (at the cost of accuracy). (default False) If
+      quantization_options is set, all quantization arg will be ignored.
+    quantize_to_float16: Boolean indicating whether to convert float buffers to
+      float16. (default False)
+    dump_graphviz_dir: Full filepath of folder to dump the graphs at various
+      stages of processing GraphViz .dot files. Preferred over
+      --output_format=GRAPHVIZ_DOT in order to keep the requirements of the
+      output file. (default None)
+    dump_graphviz_video: Boolean indicating whether to dump the graph after
+      every graph transformation. (default False)
+    target_ops: Experimental flag, subject to change. Set of OpsSet options
+      indicating which converter to use. (default set([OpsSet.TFLITE_BUILTINS]))
+    conversion_summary_dir: A string, the path to the generated conversion logs.
+    select_user_tf_ops: List of user's defined TensorFlow ops need to be
+      supported in the TensorFlow Lite runtime. These ops will be supported as
+      select TensorFlow ops.
+    allow_all_select_tf_ops: If True, automatically add all TF ops (including
+      custom TF ops) to the converted model as flex ops.
+    enable_tflite_resource_variables: Experimental flag, subject to change.
+      Enables conversion of resource variables. (default False)
+    unfold_batchmatmul: Whether to unfold tf.BatchMatMul to a set of
+      tfl.fully_connected ops. If not, translate to tfl.batch_matmul.
+    legalize_custom_tensor_list_ops: Whether to legalize `tf.TensorList*` ops to
+      tfl custom if they can all be supported.
+    lower_tensor_list_ops: Whether to lower tensor list ops to builtin ops. If
+      not, use Flex tensor list ops.
+    default_to_single_batch_in_tensor_list_ops: Whether to force to use batch
+      size one when the tensor list ops has the unspecified batch size.
+    accumulation_type: Data type of the accumulators in quantized inference.
+      Typically used for float16 quantization and is either fp16 or fp32.
+    allow_bfloat16: Whether the converted model supports reduced precision
+      inference with the bfloat16 type.
+    unfold_large_splat_constant: Whether to unfold large splat constant tensors
+      in the flatbuffer model to reduce size.
+    supported_backends: List of TFLite backends which needs to check
+      compatibility.
+    disable_per_channel_quantization: Disable per-channel quantized weights for
+      dynamic range quantization. Only per-tensor quantization will be used.
+    enable_mlir_dynamic_range_quantizer: Enable MLIR dynamic range quantization.
+      If False, the old converter dynamic range quantizer is used.
+    tf_quantization_mode: Indicates the mode of TF Quantization when the output
+      model is used for TF Quantization.
+    disable_infer_tensor_range: Disable infering tensor ranges.
+    use_fake_quant_num_bits: Allow quantization parameters to be calculated from
+      num_bits attribute.
+    enable_dynamic_update_slice: Enable to convert to DynamicUpdateSlice op.
+      (default: False).
+    preserve_assert_op: Whether to preserve `TF::AssertOp` (default: False).
+    guarantee_all_funcs_one_use: Whether to clone functions so that each
+      function only has a single use. This option will be helpful if the
+      conversion fails when the `PartitionedCall` or `StatefulPartitionedCall`
+      can't be properly inlined (default: False).
+    enable_mlir_variable_quantization: Enable MLIR variable quantization. There
+      is a variable freezing pass, but some variables may not be fully frozen by
+      it. This flag enables quantization of those residual variables in the MLIR
+      graph.
+    disable_fuse_mul_and_fc: Disable fusing input multiplication with
+      fullyconnected operations. Useful when quantizing weights.
+    quantization_options: Config to indicate quantization options of each
+      components (ex: weight, bias, activation). This can be a preset method or
+      a custom method, and allows finer, modular control. This option will
+      override any other existing quantization flags. We plan on gradually
+      migrating all quantization-related specs into this option.
+    mlir_dump_dir: A string specifying the target directory to output MLIR dumps
+      produced during conversion. If populated, enables MLIR dumps.
+    mlir_dump_pass_regex: A string containing a regular expression for filtering
+      the pass names to be dumped. Effective only if `mlir_dump_dir` is
+      populated.
+    mlir_dump_func_regex: A string containing a regular expression for filtering
+      the function names to be dumped. Effective only if `mlir_dump_dir` is
+      populated.
+    mlir_enable_timing: A boolean, if set to true reports the execution time of
+      each MLIR pass.
+    mlir_print_ir_before: A string containing a regular expression. If
+      specified, prints MLIR before passes which match.
+    mlir_print_ir_after: A string containing a regular expression. If specified,
+      prints MLIR after passes which match.
+    mlir_print_ir_module_scope: A boolean, if set to true always print the
+      top-level operation when printing IR for print_ir_[before|after].
+    mlir_elide_elementsattrs_if_larger: An int, if specified elides
+      ElementsAttrs with '...' that have more elements than the given upper
+      limit.
+    use_buffer_offset: Force the model use buffer_offset & buffer_size fields
+      instead of data. i.e. store the constant tensor and custom op binaries
+      outside of Flatbuffers
+    reduce_type_precision: Convert some tensor types to a lower precision if all
+      values within that tensor are within the range of the lower precision.
+      This could have side effects e.g. reduced flatbuffer size.
+
+  Returns:
+    conversion_flags: protocol buffer describing the conversion process.
+  Raises:
+    ValueError, if the input tensor type is unknown.
+  """
+  conversion_flags = _conversion_flags_pb2.TocoFlags()
+  conversion_flags.inference_type = convert_inference_tf_type_to_tflite_type(
+      inference_type, usage="inference_type flag"
+  )
+  if inference_input_type:
+    conversion_flags.inference_input_type = (
+        convert_inference_tf_type_to_tflite_type(
+            inference_input_type, usage="inference_input_type flag"
+        )
+    )
+  else:
+    conversion_flags.inference_input_type = conversion_flags.inference_type
+  conversion_flags.input_format = input_format
+  conversion_flags.output_format = output_format
+  if default_ranges_stats:
+    conversion_flags.default_ranges_min = default_ranges_stats[0]
+    conversion_flags.default_ranges_max = default_ranges_stats[1]
+  conversion_flags.drop_control_dependency = drop_control_dependency
+  conversion_flags.reorder_across_fake_quant = reorder_across_fake_quant
+  conversion_flags.allow_custom_ops = allow_custom_ops
+  conversion_flags.post_training_quantize = post_training_quantize
+  conversion_flags.quantize_to_float16 = quantize_to_float16
+  if dump_graphviz_dir:
+    conversion_flags.dump_graphviz_dir = dump_graphviz_dir
+  conversion_flags.dump_graphviz_include_video = dump_graphviz_video
+  if target_ops:
+    if OpsSet.SELECT_TF_OPS in target_ops:
+      conversion_flags.enable_select_tf_ops = True
+    if set(target_ops) == {OpsSet.SELECT_TF_OPS}:
+      conversion_flags.force_select_tf_ops = True
+    if OpsSet.EXPERIMENTAL_STABLEHLO_OPS in target_ops:
+      conversion_flags.convert_to_stablehlo = True
+    if OpsSet.EXPERIMENTAL_STABLEHLO_OPS in target_ops and len(target_ops) > 1:
+      raise ValueError(
+          "StableHLO Ops set can not be specified with other Ops set together"
+      )
+  if conversion_summary_dir:
+    conversion_flags.conversion_summary_dir = conversion_summary_dir
+  if select_user_tf_ops:
+    conversion_flags.select_user_tf_ops.extend(select_user_tf_ops)
+  conversion_flags.allow_all_select_tf_ops = allow_all_select_tf_ops
+  conversion_flags.enable_tflite_resource_variables = (
+      enable_tflite_resource_variables
+  )
+  conversion_flags.unfold_batchmatmul = unfold_batchmatmul
+  conversion_flags.legalize_custom_tensor_list_ops = (
+      legalize_custom_tensor_list_ops
+  )
+  conversion_flags.lower_tensor_list_ops = lower_tensor_list_ops
+  conversion_flags.default_to_single_batch_in_tensor_list_ops = (
+      default_to_single_batch_in_tensor_list_ops
+  )
+  if accumulation_type:
+    conversion_flags.accumulation_type = convert_tensor_tf_type_to_tflite_type(
+        accumulation_type, usage="accumulation_type flag"
+    )
+  conversion_flags.allow_bfloat16 = allow_bfloat16
+  conversion_flags.unfold_large_splat_constant = unfold_large_splat_constant
+  if supported_backends:
+    conversion_flags.supported_backends.extend(supported_backends)
+  conversion_flags.disable_per_channel_quantization = (
+      disable_per_channel_quantization
+  )
+  conversion_flags.enable_mlir_dynamic_range_quantizer = (
+      enable_mlir_dynamic_range_quantizer
+  )
+  conversion_flags.enable_dynamic_update_slice = enable_dynamic_update_slice
+  conversion_flags.preserve_assert_op = preserve_assert_op
+  conversion_flags.guarantee_all_funcs_one_use = guarantee_all_funcs_one_use
+  if tf_quantization_mode:
+    conversion_flags.tf_quantization_mode = tf_quantization_mode
+  conversion_flags.disable_infer_tensor_range = disable_infer_tensor_range
+  conversion_flags.use_fake_quant_num_bits = use_fake_quant_num_bits
+  conversion_flags.enable_mlir_variable_quantization = (
+      enable_mlir_variable_quantization
+  )
+  conversion_flags.disable_fuse_mul_and_fc = disable_fuse_mul_and_fc
+  if quantization_options:
+    conversion_flags.quantization_options.CopyFrom(quantization_options)
+
+  # Transfer debug options. Check for existence before populating in order to
+  # leverage defaults specified in proto definition.
+  if mlir_dump_dir is not None:
+    conversion_flags.debug_options.mlir_dump_dir = mlir_dump_dir
+  if mlir_dump_pass_regex is not None:
+    conversion_flags.debug_options.mlir_dump_pass_regex = mlir_dump_pass_regex
+  if mlir_dump_func_regex is not None:
+    conversion_flags.debug_options.mlir_dump_func_regex = mlir_dump_func_regex
+  if mlir_enable_timing is not None:
+    conversion_flags.debug_options.mlir_enable_timing = mlir_enable_timing
+  if mlir_print_ir_before is not None:
+    conversion_flags.debug_options.mlir_print_ir_before = mlir_print_ir_before
+  if mlir_print_ir_after is not None:
+    conversion_flags.debug_options.mlir_print_ir_after = mlir_print_ir_after
+  if mlir_print_ir_module_scope is not None:
+    conversion_flags.debug_options.mlir_print_ir_module_scope = (
+        mlir_print_ir_module_scope
+    )
+  if mlir_elide_elementsattrs_if_larger is not None:
+    conversion_flags.debug_options.mlir_elide_elementsattrs_if_larger = (
+        mlir_elide_elementsattrs_if_larger
+    )
+
+  if use_buffer_offset is not None:
+    conversion_flags.use_buffer_offset = use_buffer_offset
+  if reduce_type_precision is not None:
+    conversion_flags.reduce_type_precision = reduce_type_precision
+  return conversion_flags
+
+
+@convert_phase(
+    Component.CONVERT_TF_TO_TFLITE_MODEL, SubComponent.CONVERT_GRAPHDEF
+)
+def convert_graphdef_with_arrays(
+    input_data,
+    input_arrays_with_shape,
+    output_arrays,
+    control_output_arrays,
+    **kwargs
+):
+  """Convert a frozen GraphDef that can't be loaded in TF.
+
+  Conversion can be customized by providing arguments that are forwarded to
+  `build_model_flags` and `build_conversion_flags` (see documentation).
+
+  Args:
+    input_data: Input data (i.e. often `sess.graph_def`),
+    input_arrays_with_shape: Tuple of strings representing input tensor names
+      and list of integers representing input shapes (e.g., [("foo" : [1, 16,
+      16, 3])]). Use only when graph cannot be loaded into TensorFlow and when
+      `input_tensors` is None.
+    output_arrays: List of output tensors to freeze graph with. Use only when
+      graph cannot be loaded into TensorFlow and when `output_tensors` is None.
+    control_output_arrays: Control output node names. This is used when
+      converting a Graph with no output tensors. For example, if the graph's
+      last operation is a Print op, just specify that op's name in this field.
+      This can be used together with the `output_arrays` parameter.
+    **kwargs: See `build_model_flags` and `build_conversion_flags`.
+
+  Returns:
+    The converted data. For example if TFLite was the destination, then
+    this will be a tflite flatbuffer in a bytes array.
+
+  Raises:
+    Defined in `build_conversion_flags`.
+  """
+  model_flags = build_model_flags(**kwargs)
+  conversion_flags = build_conversion_flags(**kwargs)
+  enable_mlir_converter = kwargs.get("enable_mlir_converter", True)
+  quantized_input_stats = kwargs.get("quantized_input_stats", None)
+
+  for idx, (name, shape) in enumerate(input_arrays_with_shape):
+    input_array = model_flags.input_arrays.add()
+    if _is_quantized_input_stats_required(conversion_flags):
+      if quantized_input_stats:
+        input_array.mean_value, input_array.std_value = quantized_input_stats[
+            idx
+        ]
+      else:
+        raise ValueError(
+            "The `quantized_input_stats` flag must be defined when either "
+            "`inference_type` flag or `inference_input_type` flag is set to "
+            "tf.int8 or tf.uint8."
+        )
+    input_array.name = name
+    input_array.shape.dims.extend(list(map(int, shape)))
+
+  if output_arrays:
+    for name in output_arrays:
+      model_flags.output_arrays.append(name)
+  if control_output_arrays:
+    for name in control_output_arrays:
+      model_flags.control_output_arrays.append(name)
+
+  data = convert(
+      model_flags,
+      conversion_flags,
+      input_data.SerializeToString(),
+      debug_info_str=None,
+      enable_mlir_converter=enable_mlir_converter,
+  )
+  return data
+
+
+@convert_phase(
+    Component.CONVERT_TF_TO_TFLITE_MODEL, SubComponent.CONVERT_GRAPHDEF
+)
+def convert_graphdef(input_data, input_tensors, output_tensors, **kwargs):
+  """Convert a frozen GraphDef model using the TF Lite converter.
+
+  Conversion can be customized by providing arguments that are forwarded to
+  `build_model_flags` and `build_conversion_flags` (see documentation).
+
+  Args:
+    input_data: Input data (i.e. often `sess.graph_def`),
+   input_tensors: List of input tensors. Type and shape are computed using
+     `foo.shape` and `foo.dtype`.
+    output_tensors: List of output tensors (only .name is used from this).
+    **kwargs: See `build_model_flags` and `build_conversion_flags`.
+
+  Returns:
+    The converted data. For example if TFLite was the destination, then
+    this will be a tflite flatbuffer in a bytes array.
+
+  Raises:
+    Defined in `build_conversion_flags`.
+  """
+  model_flags = build_model_flags(**kwargs)
+  conversion_flags = build_conversion_flags(**kwargs)
+  saved_model_dir = kwargs.get("saved_model_dir", None)
+  input_shapes = kwargs.get("input_shapes", None)
+  enable_mlir_converter = kwargs.get("enable_mlir_converter", True)
+  quantized_input_stats = kwargs.get("quantized_input_stats", None)
+  debug_info = kwargs.get("debug_info", None)
+
+  for idx, input_tensor in enumerate(input_tensors):
+    input_array = model_flags.input_arrays.add()
+    if saved_model_dir:
+      input_array.name = input_tensor.name
+    else:
+      input_array.name = util.get_tensor_name(input_tensor)
+    input_array.data_type = convert_tensor_tf_type_to_tflite_type(
+        input_tensor.dtype, usage="input type of the TensorFlow model"
+    )
+
+    if _is_quantized_input_stats_required(conversion_flags):
+      if quantized_input_stats:
+        input_array.mean_value, input_array.std_value = quantized_input_stats[
+            idx
+        ]
+      else:
+        # We should ideally raise an error here, but we don't as it would break
+        # several models/projects that depend on this workflow.
+        warnings.warn(
+            "Statistics for quantized inputs were expected, but not "
+            "specified; continuing anyway."
+        )
+
+    if input_shapes is None:
+      shape = input_tensor.shape
+    else:
+      shape = input_shapes[idx]
+
+    if shape.rank is not None:
+      # Create shapes with -1 for unknown dimensions.
+      dims = []
+      for dim in shape:
+        if dim is None or (
+            isinstance(dim, tensor_shape.Dimension) and dim.value is None
+        ):
+          dims.append(-1)
+        else:
+          dims.append(int(dim))
+      input_array.shape.dims.extend(dims)
+      input_array.shape.unknown_rank = False
+    else:
+      input_array.shape.unknown_rank = True
+
+  for output_tensor in output_tensors:
+    if saved_model_dir:
+      model_flags.output_arrays.append(output_tensor.name)
+    else:
+      model_flags.output_arrays.append(util.get_tensor_name(output_tensor))
+
+  data = convert(
+      model_flags,
+      conversion_flags,
+      input_data.SerializeToString(),
+      debug_info_str=debug_info.SerializeToString() if debug_info else None,
+      enable_mlir_converter=enable_mlir_converter,
+  )
+  return data
+
+
+@convert_phase(
+    Component.CONVERT_TF_TO_TFLITE_MODEL, SubComponent.CONVERT_SAVED_MODEL
+)
+def convert_saved_model(**kwargs):
+  """Converts a SavedModel using TF Lite converter."""
+  model_flags = build_model_flags(**kwargs)
+  conversion_flags = build_conversion_flags(**kwargs)
+  data = convert(
+      model_flags,
+      conversion_flags,
+      input_data_str=None,
+      debug_info_str=None,
+      enable_mlir_converter=True,
+  )
+  return data
+
+
+@convert_phase(
+    Component.CONVERT_TF_TO_TFLITE_MODEL, SubComponent.CONVERT_JAX_HLO
+)
+def convert_jax_hlo(input_content, input_names, is_proto_format, **kwargs):
+  """Converts a Jax hlo-based model using TFLite converter."""
+  model_flags = _model_flags_pb2.ModelFlags()
+  model_flags.use_hlo_import = True
+  if is_proto_format:
+    model_flags.hlo_file_type = _model_flags_pb2.ModelFlags.HLO_PROTO
+  else:
+    model_flags.hlo_file_type = _model_flags_pb2.ModelFlags.HLO_TEXT
+
+  # Build input names.
+  for input_name in input_names:
+    input_array = model_flags.input_arrays.add()
+    input_array.name = input_name
+
+  conversion_flags = build_conversion_flags(**kwargs)
+  data = convert(
+      model_flags,
+      conversion_flags,
+      input_data_str=input_content,
+      debug_info_str=None,
+      enable_mlir_converter=True,
+  )
+  return data
+
+
+@_tf_export(v1=["lite.toco_convert"])
+@deprecation.deprecated(None, "Use `lite.TFLiteConverter` instead.")
+def toco_convert(input_data, input_tensors, output_tensors, *args, **kwargs):
+  """Convert a TensorFlow GraphDef to TFLite.
+
+  This function is deprecated. Please use `tf.lite.TFLiteConverter` API instead.
+  Conversion can be customized by providing arguments that are forwarded to
+  `build_model_flags` and `build_conversion_flags` (see documentation for
+  details).
+  Args:
+    input_data: Input data (i.e. often `sess.graph_def`).
+    input_tensors: List of input tensors. Type and shape are computed using
+      `foo.shape` and `foo.dtype`.
+    output_tensors: List of output tensors (only .name is used from this).
+    *args: See `build_model_flags` and `build_conversion_flags`.
+    **kwargs: See `build_model_flags` and `build_conversion_flags`.
+
+  Returns:
+    The converted TensorFlow Lite model in a bytes array.
+
+  Raises:
+    Defined in `convert`.
+  """
+  kwargs["enable_mlir_converter"] = kwargs.get("enable_mlir_converter", False)
+  return convert_graphdef(
+      input_data, input_tensors, output_tensors, *args, **kwargs
+  )
+
+
+def deduplicate_readonly_buffers(tflite_model):
+  """Generates a new model byte array after deduplicating readonly buffers.
+
+  This function should be invoked after the model optimization toolkit. The
+  model optimization toolkit assumes that each tensor object owns its each
+  buffer separately.
+
+  Args:
+    tflite_model: TFLite flatbuffer in a byte array to be deduplicated.
+
+  Returns:
+    TFLite flatbuffer in a bytes array, processed with the deduplication method.
+  """
+  # Load TFLite Flatbuffer byte array into an object.
+  model = flatbuffer_utils.convert_bytearray_to_object(tflite_model)
+
+  # Get all the read-only buffers, which can be modified without causing any
+  # issue in the graph invocation stage.
+  read_only_buffer_indices = set()
+  for subgraph in model.subgraphs:
+    # To get all the read-only buffers:
+    # (1) Get all read-only input tensors.
+    # (2) Discard intermediate or output tensors.
+    # (3) Discard the subgraph's input/output tensors.
+    # (4) Gather the buffers of the read-only input tensors.
+
+    # (1) Get read-only input tensors.
+    read_only_input_tensor_indices = set()
+    for op in subgraph.operators:
+      if op.inputs is None:
+        continue
+      for i, input_tensor_idx in enumerate(op.inputs):
+        # Ignore mutable tensors.
+        if op.mutatingVariableInputs is not None:
+          # Ignore invalid tensors.
+          if (
+              i < len(op.mutatingVariableInputs)
+              and op.mutatingVariableInputs[i]
+          ):
+            continue
+        # Ignore variable tensors.
+        if subgraph.tensors[input_tensor_idx].isVariable:
+          continue
+        read_only_input_tensor_indices.add(input_tensor_idx)
+
+    # (2) Discard intermediate or output tensors.
+    for op in subgraph.operators:
+      if op.outputs is not None:
+        for output_tensor_idx in op.outputs:
+          read_only_input_tensor_indices.discard(output_tensor_idx)
+      if op.intermediates is not None:
+        for intermediate_tensor_idx in op.intermediates:
+          read_only_input_tensor_indices.discard(intermediate_tensor_idx)
+
+    # (3) Discard the subgraph's input and output tensors.
+    if subgraph.inputs is not None:
+      for input_tensor_idx in subgraph.inputs:
+        read_only_input_tensor_indices.discard(input_tensor_idx)
+    if subgraph.outputs is not None:
+      for output_tensor_idx in subgraph.outputs:
+        read_only_input_tensor_indices.discard(output_tensor_idx)
+
+    # (4) Gather the buffers of the read-only input tensors.
+    for tensor_idx in read_only_input_tensor_indices:
+      read_only_buffer_indices.add(subgraph.tensors[tensor_idx].buffer)
+
+  # Ignore invalid negative index or zero-sized buffers.
+  for buffer_idx in read_only_buffer_indices.copy():
+    if buffer_idx < 0 or (
+        model.buffers[buffer_idx].data is None
+        or isinstance(model.buffers[buffer_idx].data, list)
+        or model.buffers[buffer_idx].data.size == 0
+    ):
+      read_only_buffer_indices.discard(buffer_idx)
+
+  class BufferIndex:
+    """A class to store index, size, hash of the buffers in TFLite model."""
+
+    def __init__(self, idx, size, hash_value):
+      self.idx = idx
+      self.size = size
+      self.hash_value = hash_value
+
+  read_only_buffers = list(
+      map(
+          lambda index: BufferIndex(  # pylint: disable=g-long-lambda
+              index,
+              model.buffers[index].data.size,
+              hashlib.md5(model.buffers[index].data.data.tobytes()).hexdigest(),
+          ),
+          read_only_buffer_indices,
+      )
+  )
+
+  # Sort read_only_buffers by buffer size & hash in descending order.
+  read_only_buffers = sorted(
+      read_only_buffers,
+      key=lambda buffer: (buffer.size, buffer.hash_value),
+      reverse=True,
+  )
+
+  # Create a map of duplicate buffers (same size and same type).
+  # eg: In [1, 2, 3, 4, 5, 6] if (1, 4, 6) and (2, 5) are each, groups of buffer
+  # indices of the same size and type, then the map would be {4:1, 6:1, 5:2}
+  duplicate_buffer_map = {}
+  for i, buffer_i in enumerate(read_only_buffers):
+    # This buffer is a duplicate.
+    if buffer_i.idx in duplicate_buffer_map:
+      continue
+    # This buffer is unique. Scan rest of the list to find duplicates
+    # of this buffer and mark them accordingly.
+    for buffer_j in read_only_buffers[i + 1 :]:
+      if buffer_j.idx in duplicate_buffer_map:
+        continue
+      if buffer_i.size != buffer_j.size:
+        break
+      if buffer_i.hash_value != buffer_j.hash_value:
+        continue
+      # Found duplicate. Nullify j-th buffer and use i-th buffer instead.
+      duplicate_buffer_map[buffer_j.idx] = buffer_i.idx
+
+  # Make the duplicated tensors use the single shared buffer index.
+  for subgraph in model.subgraphs:
+    for op in subgraph.operators:
+      if op.inputs is None:
+        continue
+      for input_tensor in op.inputs:
+        buffer_idx = subgraph.tensors[input_tensor].buffer
+        if buffer_idx in duplicate_buffer_map:
+          subgraph.tensors[input_tensor].buffer = duplicate_buffer_map[
+              buffer_idx
+          ]
+
+  # Nullify the unused buffers.
+  for idx in duplicate_buffer_map:
+    model.buffers[idx].data = None
+
+  # Return a TFLite flatbuffer as a byte array.
+  return flatbuffer_utils.convert_object_to_bytearray(model)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/convert_phase.py

@@ -0,0 +1,219 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for collecting TFLite metrics."""
+
+import collections
+import enum
+import functools
+from typing import Text
+
+from tensorflow.lite.python.metrics import converter_error_data_pb2
+from tensorflow.lite.python.metrics import metrics
+
+
+class Component(enum.Enum):
+  """Enum class defining name of the converter components."""
+  # Validate the given input and prepare and optimize TensorFlow Model.
+  PREPARE_TF_MODEL = "PREPARE_TF_MODEL"
+
+  # Convert to TFLite model format.
+  CONVERT_TF_TO_TFLITE_MODEL = "CONVERT_TF_TO_TFLITE_MODEL"
+
+  # RUN quantization and sparsification.
+  OPTIMIZE_TFLITE_MODEL = "OPTIMIZE_TFLITE_MODEL"
+
+
+SubComponentItem = collections.namedtuple("SubComponentItem",
+                                          ["name", "component"])
+
+
+class SubComponent(SubComponentItem, enum.Enum):
+  """Enum class defining name of the converter subcomponents.
+
+  This enum only defines the subcomponents in Python, there might be more
+  subcomponents defined in C++.
+  """
+
+  def __str__(self):
+    return self.value.name
+
+  @property
+  def name(self):
+    return self.value.name
+
+  @property
+  def component(self):
+    return self.value.component
+
+  # The subcomponent name is unspecified.
+  UNSPECIFIED = SubComponentItem("UNSPECIFIED", None)
+
+  # Valid the given input and parameters.
+  VALIDATE_INPUTS = SubComponentItem("VALIDATE_INPUTS",
+                                     Component.PREPARE_TF_MODEL)
+
+  # Load GraphDef from SavedModel.
+  LOAD_SAVED_MODEL = SubComponentItem("LOAD_SAVED_MODEL",
+                                      Component.PREPARE_TF_MODEL)
+
+  # Convert a SavedModel to frozen graph.
+  FREEZE_SAVED_MODEL = SubComponentItem("FREEZE_SAVED_MODEL",
+                                        Component.PREPARE_TF_MODEL)
+
+  # Save a Keras model to SavedModel.
+  CONVERT_KERAS_TO_SAVED_MODEL = SubComponentItem(
+      "CONVERT_KERAS_TO_SAVED_MODEL", Component.PREPARE_TF_MODEL)
+
+  # Save Concrete functions to SavedModel.
+  CONVERT_CONCRETE_FUNCTIONS_TO_SAVED_MODEL = SubComponentItem(
+      "CONVERT_CONCRETE_FUNCTIONS_TO_SAVED_MODEL", Component.PREPARE_TF_MODEL)
+
+  # Convert a Keras model to a frozen graph.
+  FREEZE_KERAS_MODEL = SubComponentItem("FREEZE_KERAS_MODEL",
+                                        Component.PREPARE_TF_MODEL)
+
+  # Replace all the variables with constants in a ConcreteFunction.
+  FREEZE_CONCRETE_FUNCTION = SubComponentItem("FREEZE_CONCRETE_FUNCTION",
+                                              Component.PREPARE_TF_MODEL)
+
+  # Run grappler optimization.
+  OPTIMIZE_TF_MODEL = SubComponentItem("OPTIMIZE_TF_MODEL",
+                                       Component.PREPARE_TF_MODEL)
+
+  # Convert using the old TOCO converter.
+  CONVERT_GRAPHDEF_USING_DEPRECATED_CONVERTER = SubComponentItem(
+      "CONVERT_GRAPHDEF_USING_DEPRECATED_CONVERTER",
+      Component.CONVERT_TF_TO_TFLITE_MODEL)
+
+  # Convert a GraphDef to TFLite model.
+  CONVERT_GRAPHDEF = SubComponentItem("CONVERT_GRAPHDEF",
+                                      Component.CONVERT_TF_TO_TFLITE_MODEL)
+
+  # Convert a SavedModel to TFLite model.
+  CONVERT_SAVED_MODEL = SubComponentItem("CONVERT_SAVED_MODEL",
+                                         Component.CONVERT_TF_TO_TFLITE_MODEL)
+
+  # Convert a Jax HLO to TFLite model.
+  CONVERT_JAX_HLO = SubComponentItem("CONVERT_JAX_HLO",
+                                     Component.CONVERT_TF_TO_TFLITE_MODEL)
+
+  # Do quantization by the deprecated quantizer.
+  QUANTIZE_USING_DEPRECATED_QUANTIZER = SubComponentItem(
+      "QUANTIZE_USING_DEPRECATED_QUANTIZER", Component.OPTIMIZE_TFLITE_MODEL)
+
+  # Do calibration.
+  CALIBRATE = SubComponentItem("CALIBRATE", Component.OPTIMIZE_TFLITE_MODEL)
+
+  # Do quantization by MLIR.
+  QUANTIZE = SubComponentItem("QUANTIZE", Component.OPTIMIZE_TFLITE_MODEL)
+
+  # Do sparsification by MLIR.
+  SPARSIFY = SubComponentItem("SPARSIFY", Component.OPTIMIZE_TFLITE_MODEL)
+
+
+class ConverterError(Exception):
+  """Raised when an error occurs during model conversion."""
+
+  def __init__(self, message):
+    super(ConverterError, self).__init__(message)
+    self.errors = []
+    self._parse_error_message(message)
+
+  def append_error(self,
+                   error_data: converter_error_data_pb2.ConverterErrorData):
+    self.errors.append(error_data)
+
+  def _parse_error_message(self, message):
+    """If the message matches a pattern, assigns the associated error code.
+
+    It is difficult to assign an error code to some errrors in MLIR side, Ex:
+    errors thrown by other components than TFLite or not using mlir::emitError.
+    This function try to detect them by the error message and assign the
+    corresponding error code.
+
+    Args:
+      message: The error message of this exception.
+    """
+    error_code_mapping = {
+        "Failed to functionalize Control Flow V1 ops. Consider using Control "
+        "Flow V2 ops instead. See https://www.tensorflow.org/api_docs/python/"
+        "tf/compat/v1/enable_control_flow_v2.":
+            converter_error_data_pb2.ConverterErrorData
+            .ERROR_UNSUPPORTED_CONTROL_FLOW_V1,
+    }
+    for pattern, error_code in error_code_mapping.items():
+      if pattern in message:
+        error_data = converter_error_data_pb2.ConverterErrorData()
+        error_data.error_message = message
+        error_data.error_code = error_code
+        self.append_error(error_data)
+        return
+
+
+def convert_phase(component, subcomponent=SubComponent.UNSPECIFIED):
+  """The decorator to identify converter component and subcomponent.
+
+  Args:
+    component: Converter component name.
+    subcomponent: Converter subcomponent name.
+
+  Returns:
+    Forward the result from the wrapped function.
+
+  Raises:
+    ValueError: if component and subcomponent name is not valid.
+  """
+  if component not in Component:
+    raise ValueError("Given component name not found")
+  if subcomponent not in SubComponent:
+    raise ValueError("Given subcomponent name not found")
+  if (subcomponent != SubComponent.UNSPECIFIED and
+      subcomponent.component != component):
+    raise ValueError("component and subcomponent name don't match")
+
+  def report_error(error_data: converter_error_data_pb2.ConverterErrorData):
+    # Always overwrites the component information, but only overwrites the
+    # subcomponent if it is not available.
+    error_data.component = component.value
+    if not error_data.subcomponent:
+      error_data.subcomponent = subcomponent.name
+    tflite_metrics = metrics.TFLiteConverterMetrics()
+    tflite_metrics.set_converter_error(error_data)
+
+  def report_error_message(error_message: Text):
+    error_data = converter_error_data_pb2.ConverterErrorData()
+    error_data.error_message = error_message
+    report_error(error_data)
+
+  def actual_decorator(func):
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      try:
+        return func(*args, **kwargs)
+      except ConverterError as converter_error:
+        if converter_error.errors:
+          for error_data in converter_error.errors:
+            report_error(error_data)
+        else:
+          report_error_message(str(converter_error))
+        raise converter_error from None  # Re-throws the exception.
+      except Exception as error:
+        report_error_message(str(error))
+        raise error from None  # Re-throws the exception.
+
+    return wrapper
+
+  return actual_decorator

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/convert_saved_model.py

@@ -0,0 +1,186 @@
+# 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.
+# ==============================================================================
+"""Functions to convert SavedModel to frozen GraphDefs."""
+
+from tensorflow.lite.python import util
+from tensorflow.lite.python.convert_phase import Component
+from tensorflow.lite.python.convert_phase import convert_phase
+from tensorflow.lite.python.convert_phase import SubComponent
+from tensorflow.python.client import session
+from tensorflow.python.framework import ops
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.saved_model import constants
+from tensorflow.python.saved_model import loader
+
+
+def get_meta_graph_def(saved_model_dir, tag_set):
+  """Validate saved_model and extract MetaGraphDef.
+
+  Args:
+    saved_model_dir: saved_model path to convert.
+    tag_set: Set of tag(s) of the MetaGraphDef to load.
+
+  Returns:
+    The meta_graph_def used for tflite conversion.
+
+  Raises:
+    ValueError: No valid MetaGraphDef for given tag_set.
+  """
+  with session.Session(graph=ops.Graph()) as sess:
+    return loader.load(sess, tag_set, saved_model_dir)
+
+
+def get_signature_def(meta_graph, signature_key):
+  """Get the signature def from meta_graph with given signature_key.
+
+  Args:
+    meta_graph: meta_graph_def.
+    signature_key: signature_def in the meta_graph_def.
+
+  Returns:
+    The signature_def used for tflite conversion.
+
+  Raises:
+    ValueError: Given signature_key is not valid for this meta_graph.
+  """
+  signature_def_map = meta_graph.signature_def
+  signature_def_keys = set(signature_def_map.keys())
+  logging.info(
+      "The given SavedModel MetaGraphDef contains SignatureDefs with the "
+      "following keys: %s", signature_def_keys)
+  if signature_key not in signature_def_keys:
+    raise ValueError("No '{}' in the SavedModel\'s SignatureDefs. Possible "
+                     "values are '{}'.".format(signature_key,
+                                               ",".join(signature_def_keys)))
+  return signature_def_map[signature_key]
+
+
+def get_inputs_outputs(signature_def):
+  """Get inputs and outputs from SignatureDef.
+
+  Args:
+    signature_def: SignatureDef in the meta_graph_def for conversion.
+
+  Returns:
+    The inputs and outputs in the graph for conversion.
+  """
+  inputs_tensor_info = signature_def.inputs
+  outputs_tensor_info = signature_def.outputs
+
+  def gather_names(tensor_info):
+    return [tensor_info[key].name for key in tensor_info]
+
+  inputs = gather_names(inputs_tensor_info)
+  outputs = gather_names(outputs_tensor_info)
+  return inputs, outputs
+
+
+def _get_tensors(graph, signature_def_tensor_names=None,
+                 user_tensor_names=None):
+  """Gets the tensors associated with the tensor names.
+
+  Either signature_def_tensor_names or user_tensor_names should be provided. If
+  the user provides tensors, the tensors associated with the user provided
+  tensor names are provided. Otherwise, the tensors associated with the names in
+  the SignatureDef are provided.
+
+  Args:
+    graph: GraphDef representing graph.
+    signature_def_tensor_names: Tensor names stored in either the inputs or
+      outputs of a SignatureDef. (default None)
+    user_tensor_names: Tensor names provided by the user. (default None)
+
+  Returns:
+    List of tensors.
+
+  Raises:
+    ValueError:
+      signature_def_tensors and user_tensor_names are undefined or empty.
+      user_tensor_names are not valid.
+  """
+  tensors = []
+  if user_tensor_names:
+    # Sort the tensor names.
+    user_tensor_names = sorted(user_tensor_names)
+
+    tensors = util.get_tensors_from_tensor_names(graph, user_tensor_names)
+  elif signature_def_tensor_names:
+    tensors = [
+        graph.get_tensor_by_name(name)
+        for name in sorted(signature_def_tensor_names)
+    ]
+  else:
+    # Throw ValueError if signature_def_tensors and user_tensor_names are both
+    # either undefined or empty.
+    raise ValueError(
+        "Specify either signature_def_tensor_names or user_tensor_names")
+
+  return tensors
+
+
+@convert_phase(Component.PREPARE_TF_MODEL, SubComponent.FREEZE_SAVED_MODEL)
+def freeze_saved_model(saved_model_dir, input_arrays, input_shapes,
+                       output_arrays, tag_set, signature_key):
+  """Converts a SavedModel to a frozen graph.
+
+  Args:
+    saved_model_dir: SavedModel directory to convert.
+    input_arrays: List of input tensors to freeze graph with. Uses input arrays
+      from SignatureDef when none are provided.
+    input_shapes: Dict of strings representing input tensor names to list of
+      integers representing input shapes (e.g., {"foo": : [1, 16, 16, 3]}).
+      Automatically determined when input shapes is None (e.g., {"foo" : None}).
+    output_arrays: List of output tensors to freeze graph with. Uses output
+      arrays from SignatureDef when none are provided.
+    tag_set: Set of tags identifying the MetaGraphDef within the SavedModel to
+      analyze. All tags in the tag set must be present.
+    signature_key: Key identifying SignatureDef containing inputs and outputs.
+
+  Returns:
+    frozen_graph_def: Frozen GraphDef.
+    in_tensors: List of input tensors for the graph.
+    out_tensors: List of output tensors for the graph.
+    graph: `Graph` object.
+
+  Raises:
+    ValueError:
+      SavedModel doesn't contain a MetaGraphDef identified by tag_set.
+      signature_key is not in the MetaGraphDef.
+      assets/ directory is in the MetaGraphDef.
+      input_shapes does not match the length of input_arrays.
+      input_arrays or output_arrays are not valid.
+  """
+  # Read SignatureDef.
+  meta_graph = get_meta_graph_def(saved_model_dir, tag_set)
+  signature_def = get_signature_def(meta_graph, signature_key)
+  inputs, outputs = get_inputs_outputs(signature_def)
+
+  # Check SavedModel for assets directory.
+  collection_def = meta_graph.collection_def
+  if constants.ASSETS_KEY in collection_def:
+    raise ValueError("SavedModels with assets/ directory are not supported.")
+
+  graph = ops.Graph()
+  with session.Session(graph=graph) as sess:
+    loader.load(sess, meta_graph.meta_info_def.tags, saved_model_dir)
+
+    # Gets input and output tensors.
+    # TODO(zhixianyan): Use TFLite supported Op list to filter outputs.
+    in_tensors = _get_tensors(graph, inputs, input_arrays)
+    out_tensors = _get_tensors(graph, outputs, output_arrays)
+    util.set_tensor_shapes(in_tensors, input_shapes)
+
+    frozen_graph_def = util.freeze_graph(sess, in_tensors, out_tensors)
+    return frozen_graph_def, in_tensors, out_tensors, sess.graph

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/interpreter.py

@@ -0,0 +1,994 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python TF-Lite interpreter."""
+import ctypes
+import enum
+import os
+import platform
+import sys
+
+import numpy as np
+
+# pylint: disable=g-import-not-at-top
+if not os.path.splitext(__file__)[0].endswith(
+    os.path.join('tflite_runtime', 'interpreter')):
+  # This file is part of tensorflow package.
+  from tensorflow.lite.python.interpreter_wrapper import _pywrap_tensorflow_interpreter_wrapper as _interpreter_wrapper
+  from tensorflow.lite.python.metrics import metrics
+  from tensorflow.python.util.tf_export import tf_export as _tf_export
+else:
+  # This file is part of tflite_runtime package.
+  from tflite_runtime import _pywrap_tensorflow_interpreter_wrapper as _interpreter_wrapper
+  from tflite_runtime import metrics_portable as metrics
+
+  def _tf_export(*x, **kwargs):
+    del x, kwargs
+    return lambda x: x
+
+
+# pylint: enable=g-import-not-at-top
+
+
+class Delegate:
+  """Python wrapper class to manage TfLiteDelegate objects.
+
+  The shared library is expected to have two functions,
+  tflite_plugin_create_delegate and tflite_plugin_destroy_delegate,
+  which should implement the API specified in
+  tensorflow/lite/delegates/external/external_delegate_interface.h.
+  """
+
+  def __init__(self, library, options=None):
+    """Loads delegate from the shared library.
+
+    Args:
+      library: Shared library name.
+      options: Dictionary of options that are required to load the delegate. All
+        keys and values in the dictionary should be serializable. Consult the
+        documentation of the specific delegate for required and legal options.
+        (default None)
+
+    Raises:
+      RuntimeError: This is raised if the Python implementation is not CPython.
+    """
+
+    # TODO(b/136468453): Remove need for __del__ ordering needs of CPython
+    # by using explicit closes(). See implementation of Interpreter __del__.
+    if platform.python_implementation() != 'CPython':
+      raise RuntimeError('Delegates are currently only supported into CPython'
+                         'due to missing immediate reference counting.')
+
+    self._library = ctypes.pydll.LoadLibrary(library)
+    self._library.tflite_plugin_create_delegate.argtypes = [
+        ctypes.POINTER(ctypes.c_char_p),
+        ctypes.POINTER(ctypes.c_char_p), ctypes.c_int,
+        ctypes.CFUNCTYPE(None, ctypes.c_char_p)
+    ]
+    # The return type is really 'TfLiteDelegate*', but 'void*' is close enough.
+    self._library.tflite_plugin_create_delegate.restype = ctypes.c_void_p
+
+    # Convert the options from a dictionary to lists of char pointers.
+    options = options or {}
+    options_keys = (ctypes.c_char_p * len(options))()
+    options_values = (ctypes.c_char_p * len(options))()
+    for idx, (key, value) in enumerate(options.items()):
+      options_keys[idx] = str(key).encode('utf-8')
+      options_values[idx] = str(value).encode('utf-8')
+
+    class ErrorMessageCapture:
+
+      def __init__(self):
+        self.message = ''
+
+      def report(self, x):
+        self.message += x if isinstance(x, str) else x.decode('utf-8')
+
+    capture = ErrorMessageCapture()
+    error_capturer_cb = ctypes.CFUNCTYPE(None, ctypes.c_char_p)(capture.report)
+    # Do not make a copy of _delegate_ptr. It is freed by Delegate's finalizer.
+    self._delegate_ptr = self._library.tflite_plugin_create_delegate(
+        options_keys, options_values, len(options), error_capturer_cb)
+    if self._delegate_ptr is None:
+      raise ValueError(capture.message)
+
+  def __del__(self):
+    # __del__ can not be called multiple times, so if the delegate is destroyed.
+    # don't try to destroy it twice.
+    if self._library is not None:
+      self._library.tflite_plugin_destroy_delegate.argtypes = [ctypes.c_void_p]
+      self._library.tflite_plugin_destroy_delegate(self._delegate_ptr)
+      self._library = None
+
+  def _get_native_delegate_pointer(self):
+    """Returns the native TfLiteDelegate pointer.
+
+    It is not safe to copy this pointer because it needs to be freed.
+
+    Returns:
+      TfLiteDelegate *
+    """
+    return self._delegate_ptr
+
+
+@_tf_export('lite.experimental.load_delegate')
+def load_delegate(library, options=None):
+  """Returns loaded Delegate object.
+
+  Example usage:
+
+  ```
+  import tensorflow as tf
+
+  try:
+    delegate = tf.lite.experimental.load_delegate('delegate.so')
+  except ValueError:
+    // Fallback to CPU
+
+  if delegate:
+    interpreter = tf.lite.Interpreter(
+        model_path='model.tflite',
+        experimental_delegates=[delegate])
+  else:
+    interpreter = tf.lite.Interpreter(model_path='model.tflite')
+  ```
+
+  This is typically used to leverage EdgeTPU for running TensorFlow Lite models.
+  For more information see: https://coral.ai/docs/edgetpu/tflite-python/
+
+  Args:
+    library: Name of shared library containing the
+      [TfLiteDelegate](https://www.tensorflow.org/lite/performance/delegates).
+    options: Dictionary of options that are required to load the delegate. All
+      keys and values in the dictionary should be convertible to str. Consult
+      the documentation of the specific delegate for required and legal options.
+      (default None)
+
+  Returns:
+    Delegate object.
+
+  Raises:
+    ValueError: Delegate failed to load.
+    RuntimeError: If delegate loading is used on unsupported platform.
+  """
+  try:
+    delegate = Delegate(library, options)
+  except ValueError as e:
+    raise ValueError('Failed to load delegate from {}\n{}'.format(
+        library, str(e)))
+  return delegate
+
+
+class SignatureRunner:
+  """SignatureRunner class for running TFLite models using SignatureDef.
+
+  This class should be instantiated through TFLite Interpreter only using
+  get_signature_runner method on Interpreter.
+  Example,
+  signature = interpreter.get_signature_runner("my_signature")
+  result = signature(input_1=my_input_1, input_2=my_input_2)
+  print(result["my_output"])
+  print(result["my_second_output"])
+  All names used are this specific SignatureDef names.
+
+  Notes:
+    No other function on this object or on the interpreter provided should be
+    called while this object call has not finished.
+  """
+
+  def __init__(self, interpreter=None, signature_key=None):
+    """Constructor.
+
+    Args:
+      interpreter: Interpreter object that is already initialized with the
+        requested model.
+      signature_key: SignatureDef key to be used.
+    """
+    if not interpreter:
+      raise ValueError('None interpreter provided.')
+    if not signature_key:
+      raise ValueError('None signature_key provided.')
+    self._interpreter = interpreter
+    self._interpreter_wrapper = interpreter._interpreter
+    self._signature_key = signature_key
+    signature_defs = interpreter._get_full_signature_list()
+    if signature_key not in signature_defs:
+      raise ValueError('Invalid signature_key provided.')
+    self._signature_def = signature_defs[signature_key]
+    self._outputs = self._signature_def['outputs'].items()
+    self._inputs = self._signature_def['inputs']
+
+    self._subgraph_index = (
+        self._interpreter_wrapper.GetSubgraphIndexFromSignature(
+            self._signature_key))
+
+  def __call__(self, **kwargs):
+    """Runs the SignatureDef given the provided inputs in arguments.
+
+    Args:
+      **kwargs: key,value for inputs to the model. Key is the SignatureDef input
+        name. Value is numpy array with the value.
+
+    Returns:
+      dictionary of the results from the model invoke.
+      Key in the dictionary is SignatureDef output name.
+      Value is the result Tensor.
+    """
+
+    if len(kwargs) != len(self._inputs):
+      raise ValueError(
+          'Invalid number of inputs provided for running a SignatureDef, '
+          'expected %s vs provided %s' % (len(self._inputs), len(kwargs)))
+
+    # Resize input tensors
+    for input_name, value in kwargs.items():
+      if input_name not in self._inputs:
+        raise ValueError('Invalid Input name (%s) for SignatureDef' %
+                         input_name)
+      self._interpreter_wrapper.ResizeInputTensor(
+          self._inputs[input_name], np.array(value.shape, dtype=np.int32),
+          False, self._subgraph_index)
+    # Allocate tensors.
+    self._interpreter_wrapper.AllocateTensors(self._subgraph_index)
+    # Set the input values.
+    for input_name, value in kwargs.items():
+      self._interpreter_wrapper.SetTensor(self._inputs[input_name], value,
+                                          self._subgraph_index)
+
+    self._interpreter_wrapper.Invoke(self._subgraph_index)
+    result = {}
+    for output_name, output_index in self._outputs:
+      result[output_name] = self._interpreter_wrapper.GetTensor(
+          output_index, self._subgraph_index)
+    return result
+
+  def get_input_details(self):
+    """Gets input tensor details.
+
+    Returns:
+      A dictionary from input name to tensor details where each item is a
+      dictionary with details about an input tensor. Each dictionary contains
+      the following fields that describe the tensor:
+
+      + `name`: The tensor name.
+      + `index`: The tensor index in the interpreter.
+      + `shape`: The shape of the tensor.
+      + `shape_signature`: Same as `shape` for models with known/fixed shapes.
+        If any dimension sizes are unknown, they are indicated with `-1`.
+      + `dtype`: The numpy data type (such as `np.int32` or `np.uint8`).
+      + `quantization`: Deprecated, use `quantization_parameters`. This field
+        only works for per-tensor quantization, whereas
+        `quantization_parameters` works in all cases.
+      + `quantization_parameters`: A dictionary of parameters used to quantize
+        the tensor:
+        ~ `scales`: List of scales (one if per-tensor quantization).
+        ~ `zero_points`: List of zero_points (one if per-tensor quantization).
+        ~ `quantized_dimension`: Specifies the dimension of per-axis
+        quantization, in the case of multiple scales/zero_points.
+      + `sparsity_parameters`: A dictionary of parameters used to encode a
+        sparse tensor. This is empty if the tensor is dense.
+    """
+    result = {}
+    for input_name, tensor_index in self._inputs.items():
+      result[input_name] = self._interpreter._get_tensor_details(  # pylint: disable=protected-access
+          tensor_index, self._subgraph_index)
+    return result
+
+  def get_output_details(self):
+    """Gets output tensor details.
+
+    Returns:
+      A dictionary from input name to tensor details where each item is a
+      dictionary with details about an output tensor. The dictionary contains
+      the same fields as described for `get_input_details()`.
+    """
+    result = {}
+    for output_name, tensor_index in self._outputs:
+      result[output_name] = self._interpreter._get_tensor_details(  # pylint: disable=protected-access
+          tensor_index, self._subgraph_index)
+    return result
+
+
+@_tf_export('lite.experimental.OpResolverType')
+@enum.unique
+class OpResolverType(enum.Enum):
+  """Different types of op resolvers for Tensorflow Lite.
+
+  * `AUTO`: Indicates the op resolver that is chosen by default in TfLite
+     Python, which is the "BUILTIN" as described below.
+  * `BUILTIN`: Indicates the op resolver for built-in ops with optimized kernel
+    implementation.
+  * `BUILTIN_REF`: Indicates the op resolver for built-in ops with reference
+    kernel implementation. It's generally used for testing and debugging.
+  * `BUILTIN_WITHOUT_DEFAULT_DELEGATES`: Indicates the op resolver for
+    built-in ops with optimized kernel implementation, but it will disable
+    the application of default TfLite delegates (like the XNNPACK delegate) to
+    the model graph. Generally this should not be used unless there are issues
+    with the default configuration.
+  """
+  # Corresponds to an op resolver chosen by default in TfLite Python.
+  AUTO = 0
+
+  # Corresponds to tflite::ops::builtin::BuiltinOpResolver in C++.
+  BUILTIN = 1
+
+  # Corresponds to tflite::ops::builtin::BuiltinRefOpResolver in C++.
+  BUILTIN_REF = 2
+
+  # Corresponds to
+  # tflite::ops::builtin::BuiltinOpResolverWithoutDefaultDelegates in C++.
+  BUILTIN_WITHOUT_DEFAULT_DELEGATES = 3
+
+
+def _get_op_resolver_id(op_resolver_type=OpResolverType.AUTO):
+  """Get a integer identifier for the op resolver."""
+
+  # Note: the integer identifier value needs to be same w/ op resolver ids
+  # defined in interpreter_wrapper/interpreter_wrapper.cc.
+  return {
+      # Note AUTO and BUILTIN currently share the same identifier.
+      OpResolverType.AUTO: 1,
+      OpResolverType.BUILTIN: 1,
+      OpResolverType.BUILTIN_REF: 2,
+      OpResolverType.BUILTIN_WITHOUT_DEFAULT_DELEGATES: 3
+  }.get(op_resolver_type, None)
+
+
+@_tf_export('lite.Interpreter')
+class Interpreter:
+  """Interpreter interface for running TensorFlow Lite models.
+
+  Models obtained from `TfLiteConverter` can be run in Python with
+  `Interpreter`.
+
+  As an example, lets generate a simple Keras model and convert it to TFLite
+  (`TfLiteConverter` also supports other input formats with `from_saved_model`
+  and `from_concrete_function`)
+
+  >>> x = np.array([[1.], [2.]])
+  >>> y = np.array([[2.], [4.]])
+  >>> model = tf.keras.models.Sequential([
+  ...           tf.keras.layers.Dropout(0.2),
+  ...           tf.keras.layers.Dense(units=1, input_shape=[1])
+  ...         ])
+  >>> model.compile(optimizer='sgd', loss='mean_squared_error')
+  >>> model.fit(x, y, epochs=1)
+  >>> converter = tf.lite.TFLiteConverter.from_keras_model(model)
+  >>> tflite_model = converter.convert()
+
+  `tflite_model` can be saved to a file and loaded later, or directly into the
+  `Interpreter`. Since TensorFlow Lite pre-plans tensor allocations to optimize
+  inference, the user needs to call `allocate_tensors()` before any inference.
+
+  >>> interpreter = tf.lite.Interpreter(model_content=tflite_model)
+  >>> interpreter.allocate_tensors()  # Needed before execution!
+
+  Sample execution:
+
+  >>> output = interpreter.get_output_details()[0]  # Model has single output.
+  >>> input = interpreter.get_input_details()[0]  # Model has single input.
+  >>> input_data = tf.constant(1., shape=[1, 1])
+  >>> interpreter.set_tensor(input['index'], input_data)
+  >>> interpreter.invoke()
+  >>> interpreter.get_tensor(output['index']).shape
+  (1, 1)
+
+  Use `get_signature_runner()` for a more user-friendly inference API.
+  """
+
+  def __init__(
+      self,
+      model_path=None,
+      model_content=None,
+      experimental_delegates=None,
+      num_threads=None,
+      experimental_op_resolver_type=OpResolverType.AUTO,
+      experimental_preserve_all_tensors=False,
+      experimental_disable_delegate_clustering=False,
+  ):
+    """Constructor.
+
+    Args:
+      model_path: Path to TF-Lite Flatbuffer file.
+      model_content: Content of model.
+      experimental_delegates: Experimental. Subject to change. List of
+        [TfLiteDelegate](https://www.tensorflow.org/lite/performance/delegates)
+        objects returned by lite.load_delegate().
+      num_threads: Sets the number of threads used by the interpreter and
+        available to CPU kernels. If not set, the interpreter will use an
+        implementation-dependent default number of threads. Currently, only a
+        subset of kernels, such as conv, support multi-threading. num_threads
+        should be >= -1. Setting num_threads to 0 has the effect to disable
+        multithreading, which is equivalent to setting num_threads to 1. If set
+        to the value -1, the number of threads used will be
+        implementation-defined and platform-dependent.
+      experimental_op_resolver_type: The op resolver used by the interpreter. It
+        must be an instance of OpResolverType. By default, we use the built-in
+        op resolver which corresponds to tflite::ops::builtin::BuiltinOpResolver
+        in C++.
+      experimental_preserve_all_tensors: If true, then intermediate tensors used
+        during computation are preserved for inspection, and if the passed op
+        resolver type is AUTO or BUILTIN, the type will be changed to
+        BUILTIN_WITHOUT_DEFAULT_DELEGATES so that no Tensorflow Lite default
+        delegates are applied. If false, getting intermediate tensors could
+        result in undefined values or None, especially when the graph is
+        successfully modified by the Tensorflow Lite default delegate.
+      experimental_disable_delegate_clustering: If true, don't perform delegate
+        clustering during delegate graph partitioning phase. Disabling delegate
+        clustering will make the execution order of ops respect the
+        explicitly-inserted control dependencies in the graph (inserted via
+        `with tf.control_dependencies()`) since the TF Lite converter will drop
+        control dependencies by default. Most users shouldn't turn this flag to
+        True if they don't insert explicit control dependencies or the graph
+        execution order is expected. For automatically inserted control
+        dependencies (with `tf.Variable`, `tf.Print` etc), the user doesn't need
+        to turn this flag to True since they are respected by default. Note that
+        this flag is currently experimental, and it might be removed/updated if
+        the TF Lite converter doesn't drop such control dependencies in the
+        model. Default is False.
+
+    Raises:
+      ValueError: If the interpreter was unable to create.
+    """
+    if not hasattr(self, '_custom_op_registerers'):
+      self._custom_op_registerers = []
+
+    actual_resolver_type = experimental_op_resolver_type
+    if experimental_preserve_all_tensors and (
+        experimental_op_resolver_type == OpResolverType.AUTO or
+        experimental_op_resolver_type == OpResolverType.BUILTIN):
+      actual_resolver_type = OpResolverType.BUILTIN_WITHOUT_DEFAULT_DELEGATES
+    op_resolver_id = _get_op_resolver_id(actual_resolver_type)
+    if op_resolver_id is None:
+      raise ValueError('Unrecognized passed in op resolver type: {}'.format(
+          experimental_op_resolver_type))
+
+    if model_path and not model_content:
+      custom_op_registerers_by_name = [
+          x for x in self._custom_op_registerers if isinstance(x, str)
+      ]
+      custom_op_registerers_by_func = [
+          x for x in self._custom_op_registerers if not isinstance(x, str)
+      ]
+      self._interpreter = _interpreter_wrapper.CreateWrapperFromFile(
+          model_path,
+          op_resolver_id,
+          custom_op_registerers_by_name,
+          custom_op_registerers_by_func,
+          experimental_preserve_all_tensors,
+          experimental_disable_delegate_clustering,
+      )
+      if not self._interpreter:
+        raise ValueError('Failed to open {}'.format(model_path))
+    elif model_content and not model_path:
+      custom_op_registerers_by_name = [
+          x for x in self._custom_op_registerers if isinstance(x, str)
+      ]
+      custom_op_registerers_by_func = [
+          x for x in self._custom_op_registerers if not isinstance(x, str)
+      ]
+      # Take a reference, so the pointer remains valid.
+      # Since python strings are immutable then PyString_XX functions
+      # will always return the same pointer.
+      self._model_content = model_content
+      self._interpreter = _interpreter_wrapper.CreateWrapperFromBuffer(
+          model_content,
+          op_resolver_id,
+          custom_op_registerers_by_name,
+          custom_op_registerers_by_func,
+          experimental_preserve_all_tensors,
+          experimental_disable_delegate_clustering,
+      )
+    elif not model_content and not model_path:
+      raise ValueError('`model_path` or `model_content` must be specified.')
+    else:
+      raise ValueError('Can\'t both provide `model_path` and `model_content`')
+
+    if num_threads is not None:
+      if not isinstance(num_threads, int):
+        raise ValueError('type of num_threads should be int')
+      if num_threads < 1:
+        raise ValueError('num_threads should >= 1')
+      self._interpreter.SetNumThreads(num_threads)
+
+    # Each delegate is a wrapper that owns the delegates that have been loaded
+    # as plugins. The interpreter wrapper will be using them, but we need to
+    # hold them in a list so that the lifetime is preserved at least as long as
+    # the interpreter wrapper.
+    self._delegates = []
+    if experimental_delegates:
+      self._delegates = experimental_delegates
+      for delegate in self._delegates:
+        self._interpreter.ModifyGraphWithDelegate(
+            delegate._get_native_delegate_pointer())  # pylint: disable=protected-access
+    self._signature_defs = self.get_signature_list()
+
+    self._metrics = metrics.TFLiteMetrics()
+    self._metrics.increase_counter_interpreter_creation()
+
+  def __del__(self):
+    # Must make sure the interpreter is destroyed before things that
+    # are used by it like the delegates. NOTE this only works on CPython
+    # probably.
+    # TODO(b/136468453): Remove need for __del__ ordering needs of CPython
+    # by using explicit closes(). See implementation of Interpreter __del__.
+    self._interpreter = None
+    self._delegates = None
+
+  def allocate_tensors(self):
+    self._ensure_safe()
+    return self._interpreter.AllocateTensors()
+
+  def _safe_to_run(self):
+    """Returns true if there exist no numpy array buffers.
+
+    This means it is safe to run tflite calls that may destroy internally
+    allocated memory. This works, because in the wrapper.cc we have made
+    the numpy base be the self._interpreter.
+    """
+    # NOTE, our tensor() call in cpp will use _interpreter as a base pointer.
+    # If this environment is the only _interpreter, then the ref count should be
+    # 2 (1 in self and 1 in temporary of sys.getrefcount).
+    return sys.getrefcount(self._interpreter) == 2
+
+  def _ensure_safe(self):
+    """Makes sure no numpy arrays pointing to internal buffers are active.
+
+    This should be called from any function that will call a function on
+    _interpreter that may reallocate memory e.g. invoke(), ...
+
+    Raises:
+      RuntimeError: If there exist numpy objects pointing to internal memory
+        then we throw.
+    """
+    if not self._safe_to_run():
+      raise RuntimeError("""There is at least 1 reference to internal data
+      in the interpreter in the form of a numpy array or slice. Be sure to
+      only hold the function returned from tensor() if you are using raw
+      data access.""")
+
+  # Experimental and subject to change
+  def _get_op_details(self, op_index):
+    """Gets a dictionary with arrays of ids for tensors involved with an op.
+
+    Args:
+      op_index: Operation/node index of node to query.
+
+    Returns:
+      a dictionary containing the index, op name, and arrays with lists of the
+      indices for the inputs and outputs of the op/node.
+    """
+    op_index = int(op_index)
+    op_name = self._interpreter.NodeName(op_index)
+    op_inputs = self._interpreter.NodeInputs(op_index)
+    op_outputs = self._interpreter.NodeOutputs(op_index)
+
+    details = {
+        'index': op_index,
+        'op_name': op_name,
+        'inputs': op_inputs,
+        'outputs': op_outputs,
+    }
+
+    return details
+
+  def _get_tensor_details(self, tensor_index, subgraph_index):
+    """Gets tensor details.
+
+    Args:
+      tensor_index: Tensor index of tensor to query.
+      subgraph_index: Index of the subgraph.
+
+    Returns:
+      A dictionary containing the following fields of the tensor:
+        'name': The tensor name.
+        'index': The tensor index in the interpreter.
+        'shape': The shape of the tensor.
+        'quantization': Deprecated, use 'quantization_parameters'. This field
+            only works for per-tensor quantization, whereas
+            'quantization_parameters' works in all cases.
+        'quantization_parameters': The parameters used to quantize the tensor:
+          'scales': List of scales (one if per-tensor quantization)
+          'zero_points': List of zero_points (one if per-tensor quantization)
+          'quantized_dimension': Specifies the dimension of per-axis
+              quantization, in the case of multiple scales/zero_points.
+
+    Raises:
+      ValueError: If tensor_index is invalid.
+    """
+    tensor_index = int(tensor_index)
+    subgraph_index = int(subgraph_index)
+    tensor_name = self._interpreter.TensorName(tensor_index, subgraph_index)
+    tensor_size = self._interpreter.TensorSize(tensor_index, subgraph_index)
+    tensor_size_signature = self._interpreter.TensorSizeSignature(
+        tensor_index, subgraph_index)
+    tensor_type = self._interpreter.TensorType(tensor_index, subgraph_index)
+    tensor_quantization = self._interpreter.TensorQuantization(
+        tensor_index, subgraph_index)
+    tensor_quantization_params = self._interpreter.TensorQuantizationParameters(
+        tensor_index, subgraph_index)
+    tensor_sparsity_params = self._interpreter.TensorSparsityParameters(
+        tensor_index, subgraph_index)
+
+    if not tensor_type:
+      raise ValueError('Could not get tensor details')
+
+    details = {
+        'name': tensor_name,
+        'index': tensor_index,
+        'shape': tensor_size,
+        'shape_signature': tensor_size_signature,
+        'dtype': tensor_type,
+        'quantization': tensor_quantization,
+        'quantization_parameters': {
+            'scales': tensor_quantization_params[0],
+            'zero_points': tensor_quantization_params[1],
+            'quantized_dimension': tensor_quantization_params[2],
+        },
+        'sparsity_parameters': tensor_sparsity_params
+    }
+
+    return details
+
+  # Experimental and subject to change
+  def _get_ops_details(self):
+    """Gets op details for every node.
+
+    Returns:
+      A list of dictionaries containing arrays with lists of tensor ids for
+      tensors involved in the op.
+    """
+    return [
+        self._get_op_details(idx) for idx in range(self._interpreter.NumNodes())
+    ]
+
+  def get_tensor_details(self):
+    """Gets tensor details for every tensor with valid tensor details.
+
+    Tensors where required information about the tensor is not found are not
+    added to the list. This includes temporary tensors without a name.
+
+    Returns:
+      A list of dictionaries containing tensor information.
+    """
+    tensor_details = []
+    for idx in range(self._interpreter.NumTensors(0)):
+      try:
+        tensor_details.append(self._get_tensor_details(idx, subgraph_index=0))
+      except ValueError:
+        pass
+    return tensor_details
+
+  def get_input_details(self):
+    """Gets model input tensor details.
+
+    Returns:
+      A list in which each item is a dictionary with details about
+      an input tensor. Each dictionary contains the following fields
+      that describe the tensor:
+
+      + `name`: The tensor name.
+      + `index`: The tensor index in the interpreter.
+      + `shape`: The shape of the tensor.
+      + `shape_signature`: Same as `shape` for models with known/fixed shapes.
+        If any dimension sizes are unknown, they are indicated with `-1`.
+      + `dtype`: The numpy data type (such as `np.int32` or `np.uint8`).
+      + `quantization`: Deprecated, use `quantization_parameters`. This field
+        only works for per-tensor quantization, whereas
+        `quantization_parameters` works in all cases.
+      + `quantization_parameters`: A dictionary of parameters used to quantize
+        the tensor:
+        ~ `scales`: List of scales (one if per-tensor quantization).
+        ~ `zero_points`: List of zero_points (one if per-tensor quantization).
+        ~ `quantized_dimension`: Specifies the dimension of per-axis
+        quantization, in the case of multiple scales/zero_points.
+      + `sparsity_parameters`: A dictionary of parameters used to encode a
+        sparse tensor. This is empty if the tensor is dense.
+    """
+    return [
+        self._get_tensor_details(i, subgraph_index=0)
+        for i in self._interpreter.InputIndices()
+    ]
+
+  def set_tensor(self, tensor_index, value):
+    """Sets the value of the input tensor.
+
+    Note this copies data in `value`.
+
+    If you want to avoid copying, you can use the `tensor()` function to get a
+    numpy buffer pointing to the input buffer in the tflite interpreter.
+
+    Args:
+      tensor_index: Tensor index of tensor to set. This value can be gotten from
+        the 'index' field in get_input_details.
+      value: Value of tensor to set.
+
+    Raises:
+      ValueError: If the interpreter could not set the tensor.
+    """
+    self._interpreter.SetTensor(tensor_index, value)
+
+  def resize_tensor_input(self, input_index, tensor_size, strict=False):
+    """Resizes an input tensor.
+
+    Args:
+      input_index: Tensor index of input to set. This value can be gotten from
+        the 'index' field in get_input_details.
+      tensor_size: The tensor_shape to resize the input to.
+      strict: Only unknown dimensions can be resized when `strict` is True.
+        Unknown dimensions are indicated as `-1` in the `shape_signature`
+        attribute of a given tensor. (default False)
+
+    Raises:
+      ValueError: If the interpreter could not resize the input tensor.
+
+    Usage:
+    ```
+    interpreter = Interpreter(model_content=tflite_model)
+    interpreter.resize_tensor_input(0, [num_test_images, 224, 224, 3])
+    interpreter.allocate_tensors()
+    interpreter.set_tensor(0, test_images)
+    interpreter.invoke()
+    ```
+    """
+    self._ensure_safe()
+    # `ResizeInputTensor` now only accepts int32 numpy array as `tensor_size
+    # parameter.
+    tensor_size = np.array(tensor_size, dtype=np.int32)
+    self._interpreter.ResizeInputTensor(input_index, tensor_size, strict)
+
+  def get_output_details(self):
+    """Gets model output tensor details.
+
+    Returns:
+      A list in which each item is a dictionary with details about
+      an output tensor. The dictionary contains the same fields as
+      described for `get_input_details()`.
+    """
+    return [
+        self._get_tensor_details(i, subgraph_index=0)
+        for i in self._interpreter.OutputIndices()
+    ]
+
+  def get_signature_list(self):
+    """Gets list of SignatureDefs in the model.
+
+    Example,
+    ```
+    signatures = interpreter.get_signature_list()
+    print(signatures)
+
+    # {
+    #   'add': {'inputs': ['x', 'y'], 'outputs': ['output_0']}
+    # }
+
+    Then using the names in the signature list you can get a callable from
+    get_signature_runner().
+    ```
+
+    Returns:
+      A list of SignatureDef details in a dictionary structure.
+      It is keyed on the SignatureDef method name, and the value holds
+      dictionary of inputs and outputs.
+    """
+    full_signature_defs = self._interpreter.GetSignatureDefs()
+    for _, signature_def in full_signature_defs.items():
+      signature_def['inputs'] = list(signature_def['inputs'].keys())
+      signature_def['outputs'] = list(signature_def['outputs'].keys())
+    return full_signature_defs
+
+  def _get_full_signature_list(self):
+    """Gets list of SignatureDefs in the model.
+
+    Example,
+    ```
+    signatures = interpreter._get_full_signature_list()
+    print(signatures)
+
+    # {
+    #   'add': {'inputs': {'x': 1, 'y': 0}, 'outputs': {'output_0': 4}}
+    # }
+
+    Then using the names in the signature list you can get a callable from
+    get_signature_runner().
+    ```
+
+    Returns:
+      A list of SignatureDef details in a dictionary structure.
+      It is keyed on the SignatureDef method name, and the value holds
+      dictionary of inputs and outputs.
+    """
+    return self._interpreter.GetSignatureDefs()
+
+  def get_signature_runner(self, signature_key=None):
+    """Gets callable for inference of specific SignatureDef.
+
+    Example usage,
+    ```
+    interpreter = tf.lite.Interpreter(model_content=tflite_model)
+    interpreter.allocate_tensors()
+    fn = interpreter.get_signature_runner('div_with_remainder')
+    output = fn(x=np.array([3]), y=np.array([2]))
+    print(output)
+    # {
+    #   'quotient': array([1.], dtype=float32)
+    #   'remainder': array([1.], dtype=float32)
+    # }
+    ```
+
+    None can be passed for signature_key if the model has a single Signature
+    only.
+
+    All names used are this specific SignatureDef names.
+
+
+    Args:
+      signature_key: Signature key for the SignatureDef, it can be None if and
+        only if the model has a single SignatureDef. Default value is None.
+
+    Returns:
+      This returns a callable that can run inference for SignatureDef defined
+      by argument 'signature_key'.
+      The callable will take key arguments corresponding to the arguments of the
+      SignatureDef, that should have numpy values.
+      The callable will returns dictionary that maps from output names to numpy
+      values of the computed results.
+
+    Raises:
+      ValueError: If passed signature_key is invalid.
+    """
+    if signature_key is None:
+      if len(self._signature_defs) != 1:
+        raise ValueError(
+            'SignatureDef signature_key is None and model has {0} Signatures. '
+            'None is only allowed when the model has 1 SignatureDef'.format(
+                len(self._signature_defs)))
+      else:
+        signature_key = next(iter(self._signature_defs))
+    return SignatureRunner(interpreter=self, signature_key=signature_key)
+
+  def get_tensor(self, tensor_index, subgraph_index=0):
+    """Gets the value of the output tensor (get a copy).
+
+    If you wish to avoid the copy, use `tensor()`. This function cannot be used
+    to read intermediate results.
+
+    Args:
+      tensor_index: Tensor index of tensor to get. This value can be gotten from
+        the 'index' field in get_output_details.
+      subgraph_index: Index of the subgraph to fetch the tensor. Default value
+        is 0, which means to fetch from the primary subgraph.
+
+    Returns:
+      a numpy array.
+    """
+    return self._interpreter.GetTensor(tensor_index, subgraph_index)
+
+  def tensor(self, tensor_index):
+    """Returns function that gives a numpy view of the current tensor buffer.
+
+    This allows reading and writing to this tensors w/o copies. This more
+    closely mirrors the C++ Interpreter class interface's tensor() member, hence
+    the name. Be careful to not hold these output references through calls
+    to `allocate_tensors()` and `invoke()`. This function cannot be used to read
+    intermediate results.
+
+    Usage:
+
+    ```
+    interpreter.allocate_tensors()
+    input = interpreter.tensor(interpreter.get_input_details()[0]["index"])
+    output = interpreter.tensor(interpreter.get_output_details()[0]["index"])
+    for i in range(10):
+      input().fill(3.)
+      interpreter.invoke()
+      print("inference %s" % output())
+    ```
+
+    Notice how this function avoids making a numpy array directly. This is
+    because it is important to not hold actual numpy views to the data longer
+    than necessary. If you do, then the interpreter can no longer be invoked,
+    because it is possible the interpreter would resize and invalidate the
+    referenced tensors. The NumPy API doesn't allow any mutability of the
+    the underlying buffers.
+
+    WRONG:
+
+    ```
+    input = interpreter.tensor(interpreter.get_input_details()[0]["index"])()
+    output = interpreter.tensor(interpreter.get_output_details()[0]["index"])()
+    interpreter.allocate_tensors()  # This will throw RuntimeError
+    for i in range(10):
+      input.fill(3.)
+      interpreter.invoke()  # this will throw RuntimeError since input,output
+    ```
+
+    Args:
+      tensor_index: Tensor index of tensor to get. This value can be gotten from
+        the 'index' field in get_output_details.
+
+    Returns:
+      A function that can return a new numpy array pointing to the internal
+      TFLite tensor state at any point. It is safe to hold the function forever,
+      but it is not safe to hold the numpy array forever.
+    """
+    return lambda: self._interpreter.tensor(self._interpreter, tensor_index)
+
+  def invoke(self):
+    """Invoke the interpreter.
+
+    Be sure to set the input sizes, allocate tensors and fill values before
+    calling this. Also, note that this function releases the GIL so heavy
+    computation can be done in the background while the Python interpreter
+    continues. No other function on this object should be called while the
+    invoke() call has not finished.
+
+    Raises:
+      ValueError: When the underlying interpreter fails raise ValueError.
+    """
+    self._ensure_safe()
+    self._interpreter.Invoke()
+
+  def reset_all_variables(self):
+    return self._interpreter.ResetVariableTensors()
+
+  # Experimental and subject to change.
+  def _native_handle(self):
+    """Returns a pointer to the underlying tflite::Interpreter instance.
+
+    This allows extending tflite.Interpreter's functionality in a custom C++
+    function. Consider how that may work in a custom pybind wrapper:
+
+      m.def("SomeNewFeature", ([](py::object handle) {
+        auto* interpreter =
+          reinterpret_cast<tflite::Interpreter*>(handle.cast<intptr_t>());
+        ...
+      }))
+
+    and corresponding Python call:
+
+      SomeNewFeature(interpreter.native_handle())
+
+    Note: This approach is fragile. Users must guarantee the C++ extension build
+    is consistent with the tflite.Interpreter's underlying C++ build.
+    """
+    return self._interpreter.interpreter()
+
+
+class InterpreterWithCustomOps(Interpreter):
+  """Interpreter interface for TensorFlow Lite Models that accepts custom ops.
+
+  The interface provided by this class is experimental and therefore not exposed
+  as part of the public API.
+
+  Wraps the tf.lite.Interpreter class and adds the ability to load custom ops
+  by providing the names of functions that take a pointer to a BuiltinOpResolver
+  and add a custom op.
+  """
+
+  def __init__(self, custom_op_registerers=None, **kwargs):
+    """Constructor.
+
+    Args:
+      custom_op_registerers: List of str (symbol names) or functions that take a
+        pointer to a MutableOpResolver and register a custom op. When passing
+        functions, use a pybind function that takes a uintptr_t that can be
+        recast as a pointer to a MutableOpResolver.
+      **kwargs: Additional arguments passed to Interpreter.
+
+    Raises:
+      ValueError: If the interpreter was unable to create.
+    """
+    self._custom_op_registerers = custom_op_registerers or []
+    super(InterpreterWithCustomOps, self).__init__(**kwargs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/interpreter_wrapper/_pywrap_tensorflow_interpreter_wrapper.pyi

@@ -0,0 +1,48 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from typing import Any
+
+class InterpreterWrapper:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def AllocateTensors(self, subgraph_index: int = ...) -> object: ...
+    def GetSignatureDefs(self) -> object: ...
+    def GetSubgraphIndexFromSignature(self, arg0: str) -> object: ...
+    def GetTensor(self, tensor_index: int, subgraph_index: int = ...) -> object: ...
+    def InputIndices(self) -> object: ...
+    def Invoke(self, subgraph_index: int = ...) -> object: ...
+    def ModifyGraphWithDelegate(self, arg0: int) -> object: ...
+    def NodeInputs(self, arg0: int) -> object: ...
+    def NodeName(self, arg0: int) -> str: ...
+    def NodeOutputs(self, arg0: int) -> object: ...
+    def NumNodes(self) -> int: ...
+    def NumTensors(self, arg0: int) -> int: ...
+    def OutputIndices(self) -> object: ...
+    def ResetVariableTensors(self) -> object: ...
+    def ResizeInputTensor(self, i: int, value: object, strict: bool, subgraph_index: int = ...) -> object: ...
+    def SetNumThreads(self, arg0: int) -> object: ...
+    def SetTensor(self, i: int, value: object, subgraph_index: int = ...) -> object: ...
+    def TensorName(self, arg0: int, arg1: int) -> str: ...
+    def TensorQuantization(self, arg0: int, arg1: int) -> object: ...
+    def TensorQuantizationParameters(self, arg0: int, arg1: int) -> object: ...
+    def TensorSize(self, arg0: int, arg1: int) -> object: ...
+    def TensorSizeSignature(self, arg0: int, arg1: int) -> object: ...
+    def TensorSparsityParameters(self, arg0: int, arg1: int) -> object: ...
+    def TensorType(self, arg0: int, arg1: int) -> object: ...
+    def interpreter(self) -> int: ...
+    def tensor(self, base_object: object, tensor_index: int, subgraph_index: int = ...) -> object: ...
+
+def CreateWrapperFromBuffer(*args, **kwargs) -> Any: ...
+def CreateWrapperFromFile(*args, **kwargs) -> Any: ...

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/lite_constants.py

@@ -0,0 +1,70 @@
+# 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.
+# ==============================================================================
+"""Constants for TFLite."""
+
+from tensorflow.lite.toco import toco_flags_pb2 as _toco_flags_pb2
+from tensorflow.python.framework import dtypes
+from tensorflow.python.util.all_util import remove_undocumented
+from tensorflow.python.util.tf_export import tf_export as _tf_export
+
+FLOAT = dtypes.float32
+FLOAT16 = dtypes.float16
+INT32 = dtypes.int32
+INT64 = dtypes.int64
+STRING = dtypes.string
+QUANTIZED_UINT8 = dtypes.uint8
+INT8 = dtypes.int8
+INT16 = dtypes.int16
+COMPLEX64 = dtypes.complex64
+TENSORFLOW_GRAPHDEF = _toco_flags_pb2.TENSORFLOW_GRAPHDEF
+TFLITE = _toco_flags_pb2.TFLITE
+GRAPHVIZ_DOT = _toco_flags_pb2.GRAPHVIZ_DOT
+
+_tf_export(v1=["lite.constants.FLOAT"]).export_constant(__name__, "FLOAT")
+_tf_export(v1=["lite.constants.FLOAT16"]).export_constant(__name__, "FLOAT16")
+_tf_export(v1=["lite.constants.INT32"]).export_constant(__name__, "INT32")
+_tf_export(v1=["lite.constants.INT64"]).export_constant(__name__, "INT64")
+_tf_export(v1=["lite.constants.STRING"]).export_constant(__name__, "STRING")
+_tf_export(v1=["lite.constants.QUANTIZED_UINT8"]).export_constant(
+    __name__, "QUANTIZED_UINT8")
+_tf_export(v1=["lite.constants.INT8"]).export_constant(__name__, "INT8")
+_tf_export(v1=["lite.constants.INT16"]).export_constant(__name__, "INT16")
+_tf_export(v1=["lite.constants.TFLITE"]).export_constant(__name__, "TFLITE")
+_tf_export(v1=["lite.constants.GRAPHVIZ_DOT"]).export_constant(
+    __name__, "GRAPHVIZ_DOT")
+
+# Currently the default mode of operation is to shell to another python process
+# to protect against crashes. However, it breaks some dependent targets because
+# it forces us to depend on an external py_binary. The experimental API doesn't
+# have that drawback.
+EXPERIMENTAL_USE_TOCO_API_DIRECTLY = False
+
+
+_allowed_symbols = [
+    "FLOAT",
+    "FLOAT16",
+    "INT32",
+    "INT64",
+    "STRING",
+    "QUANTIZED_UINT8",
+    "INT8",
+    "INT16",
+    "COMPLEX64",
+    "TENSORFLOW_GRAPHDEF",
+    "TFLITE",
+    "GRAPHVIZ_DOT",
+    "EXPERIMENTAL_USE_TOCO_API_DIRECTLY",
+]
+remove_undocumented(__name__, _allowed_symbols)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/metrics/_pywrap_tensorflow_lite_metrics_wrapper.pyi

@@ -0,0 +1,18 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+class MetricsWrapper:
+    def __init__(self, arg0: str) -> None: ...
+    def ExportMetrics(self) -> object: ...

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/metrics/converter_error_data_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/python/metrics/converter_error_data.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n9tensorflow/lite/python/metrics/converter_error_data.proto\x12\x0etflite.metrics\"\xdc\x06\n\x12\x43onverterErrorData\x12\x11\n\tcomponent\x18\x01 \x01(\t\x12\x14\n\x0csubcomponent\x18\x02 \x01(\t\x12@\n\nerror_code\x18\x03 \x01(\x0e\x32,.tflite.metrics.ConverterErrorData.ErrorCode\x12\x15\n\rerror_message\x18\x04 \x01(\t\x12=\n\x08operator\x18\x05 \x01(\x0b\x32+.tflite.metrics.ConverterErrorData.Operator\x12=\n\x08location\x18\x06 \x01(\x0b\x32+.tflite.metrics.ConverterErrorData.Location\x1a\x18\n\x08Operator\x12\x0c\n\x04name\x18\x01 \x01(\t\x1a\x39\n\x07\x46ileLoc\x12\x10\n\x08\x66ilename\x18\x01 \x01(\t\x12\x0c\n\x04line\x18\x02 \x01(\r\x12\x0e\n\x06\x63olumn\x18\x03 \x01(\r\x1aU\n\tSourceLoc\x12\x0c\n\x04name\x18\x01 \x01(\t\x12:\n\x06source\x18\x02 \x01(\x0b\x32*.tflite.metrics.ConverterErrorData.FileLoc\x1a\x85\x01\n\x08Location\x12=\n\x04type\x18\x01 \x01(\x0e\x32/.tflite.metrics.ConverterErrorData.LocationType\x12:\n\x04\x63\x61ll\x18\x02 \x03(\x0b\x32,.tflite.metrics.ConverterErrorData.SourceLoc\"\xc5\x01\n\tErrorCode\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x18\n\x14\x45RROR_NEEDS_FLEX_OPS\x10\x01\x12\x1a\n\x16\x45RROR_NEEDS_CUSTOM_OPS\x10\x02\x12%\n!ERROR_UNSUPPORTED_CONTROL_FLOW_V1\x10\x03\x12/\n+ERROR_STATEFUL_PARTITIONED_CALL_IN_FINAL_IR\x10\x04\x12\x1d\n\x18\x45RROR_GPU_NOT_COMPATIBLE\x10\xc8\x01\"J\n\x0cLocationType\x12\x0e\n\nUNKNOWNLOC\x10\x00\x12\x0b\n\x07NAMELOC\x10\x01\x12\x0f\n\x0b\x43\x41LLSITELOC\x10\x02\x12\x0c\n\x08\x46USEDLOC\x10\x03')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.python.metrics.converter_error_data_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _CONVERTERERRORDATA._serialized_start=78
+  _CONVERTERERRORDATA._serialized_end=938
+  _CONVERTERERRORDATA_OPERATOR._serialized_start=356
+  _CONVERTERERRORDATA_OPERATOR._serialized_end=380
+  _CONVERTERERRORDATA_FILELOC._serialized_start=382
+  _CONVERTERERRORDATA_FILELOC._serialized_end=439
+  _CONVERTERERRORDATA_SOURCELOC._serialized_start=441
+  _CONVERTERERRORDATA_SOURCELOC._serialized_end=526
+  _CONVERTERERRORDATA_LOCATION._serialized_start=529
+  _CONVERTERERRORDATA_LOCATION._serialized_end=662
+  _CONVERTERERRORDATA_ERRORCODE._serialized_start=665
+  _CONVERTERERRORDATA_ERRORCODE._serialized_end=862
+  _CONVERTERERRORDATA_LOCATIONTYPE._serialized_start=864
+  _CONVERTERERRORDATA_LOCATIONTYPE._serialized_end=938
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/metrics/metrics.py

@@ -0,0 +1,70 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python TFLite metrics helper."""
+import os
+from typing import Optional, Text
+
+# pylint: disable=g-import-not-at-top
+if not os.path.splitext(__file__)[0].endswith(
+    os.path.join('tflite_runtime', 'metrics_portable')):
+  # This file is part of tensorflow package.
+  from tensorflow.lite.python.metrics import metrics_interface  # type: ignore
+else:
+  # This file is part of tflite_runtime package.
+  from tflite_runtime import metrics_interface  # type: ignore
+# pylint: enable=g-import-not-at-top
+
+
+class TFLiteMetrics(metrics_interface.TFLiteMetricsInterface):
+  """TFLite metrics helper."""
+
+  def __init__(self,
+               model_hash: Optional[Text] = None,
+               model_path: Optional[Text] = None) -> None:
+    pass
+
+  def increase_counter_debugger_creation(self):
+    pass
+
+  def increase_counter_interpreter_creation(self):
+    pass
+
+  def increase_counter_converter_attempt(self):
+    pass
+
+  def increase_counter_converter_success(self):
+    pass
+
+  def set_converter_param(self, name, value):
+    pass
+
+  def set_converter_error(self, error_data):
+    pass
+
+  def set_converter_latency(self, value):
+    pass
+
+
+class TFLiteConverterMetrics(TFLiteMetrics):
+  """Similar to TFLiteMetrics but specialized for converter."""
+
+  def __del__(self):
+    pass
+
+  def set_export_required(self):
+    pass
+
+  def export_metrics(self):
+    pass

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/metrics/metrics_interface.py

@@ -0,0 +1,48 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python TFLite metrics helper interface."""
+import abc
+
+
+class TFLiteMetricsInterface(metaclass=abc.ABCMeta):
+  """Abstract class for TFLiteMetrics."""
+
+  @abc.abstractmethod
+  def increase_counter_debugger_creation(self):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def increase_counter_interpreter_creation(self):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def increase_counter_converter_attempt(self):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def increase_counter_converter_success(self):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def set_converter_param(self, name, value):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def set_converter_error(self, error_data):
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def set_converter_latency(self, value):
+    raise NotImplementedError

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/metrics/wrapper/metrics_wrapper.py

@@ -0,0 +1,34 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Stub to make pywrap metrics wrapper accessible."""
+
+from tensorflow.lite.python import wrap_toco
+from tensorflow.lite.python.metrics import converter_error_data_pb2
+from tensorflow.lite.python.metrics._pywrap_tensorflow_lite_metrics_wrapper import MetricsWrapper  # pylint: disable=unused-import
+
+
+def retrieve_collected_errors():
+  """Returns and clears the list of collected errors in ErrorCollector.
+
+  The RetrieveCollectedErrors function in C++ returns a list of serialized proto
+  messages. This function will convert them to ConverterErrorData instances.
+
+  Returns:
+    A list of ConverterErrorData.
+  """
+  serialized_message_list = wrap_toco.wrapped_retrieve_collected_errors()
+  return list(
+      map(converter_error_data_pb2.ConverterErrorData.FromString,
+          serialized_message_list))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/op_hint.py

@@ -0,0 +1,1338 @@
+# 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.
+# ==============================================================================
+"""Define tflite op hints (intrinsic operations).
+
+This essentially allows defining a TensorFlow API for tflite operations in
+Python with hints on how they are represented in TensorFlow Lite. This basically
+is a form of tflite intrinsic. It wraps a subpart of a TensorFlow execution
+graph and is useful for LSTMs and other complicated TensorFlow constructions
+that are difficult to pattern match in TOCO, but are represented by a single
+accelerated tflite op.
+
+Example:
+  def tflite_cool_activation(input):
+    # A cool activation function.
+    custom = tf.lite.OpHint("cool_activation")
+    input, = custom.add_inputs(input)
+    output = tf.sigmoid(input) * input
+    output, = custom.add_outputs(output)
+    return output
+
+  image = tf.compat.v1.placeholder(tf.float32, (1, 16, 16, 1))
+  output = tf.identity(tflite_cool_activation(image))
+
+  session = tf.compat.v1.Session()
+
+  graphdef_to_convert = tf.lite.experimental.convert_op_hints_to_stubs(session)
+  tflite_graph = tf.compat.v1.lite.toco_convert(
+      graphdef_to_convert, [image], [output], allow_custom_ops=True)
+  with open("/tmp/graph.fb", "wb") as fp:
+    fp.write(tflite_graph)
+
+How does it work?:
+
+OpHint is a helper that you use when defining a vanilla python function.
+It allows you to wrap arguments with tf.identities with some custom attributes.
+These attributes allow you to find the original block of ops that was created.
+For example, if you use cool_activation above you essentially get:
+
+a_input = tf.identity()
+result = tf.multiply(tf.sigmoid(a_input), a_input)
+output = tf.identity()
+
+a_input, output are identities that have parameters representing
+what argument they are, what the name of the function they should turn into
+in tf lite as well as a guid that uniquely identifies a particular invocation.
+
+Once you have built your whole tensorflow graph, you can run it and train it
+as usual, but after you have done that, you need to convert the graph into
+a form that replaces these subgraphs wrapped in identities to stub ops. These
+ops don't actually exist in the normal TensorFlow runtime, but will be
+understood by toco later. The generated TensorFlow Lite flatbuffer file will
+contain a custom operator called "cool_activation". Developer needs to implement
+and register this operator in TensorFlow Lite in order to do inference.
+"""
+
+import collections as _collections
+import copy as _copy
+import json as _json
+import uuid as _uuid
+
+from tensorflow.core.framework import attr_value_pb2 as _attr_value_pb2
+from tensorflow.core.framework import graph_pb2 as _graph_pb2
+from tensorflow.core.framework import node_def_pb2 as _node_def_pb2
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import tensor_util as _tensor_util
+from tensorflow.python.framework.graph_util_impl import _bfs_for_reachable_nodes
+from tensorflow.python.framework.graph_util_impl import _extract_graph_summary
+from tensorflow.python.ops import array_ops as _array_ops
+from tensorflow.python.util import compat as _compat
+from tensorflow.python.util import deprecation as _deprecation
+from tensorflow.python.util.all_util import remove_undocumented
+from tensorflow.python.util.tf_export import tf_export as _tf_export
+
+
+@_tf_export(v1=["lite.OpHint"])
+@_deprecation.deprecated(
+    None,
+    "Please follow instructions under "
+    "https://www.tensorflow.org/lite/convert/operation_fusion for operation"
+    "fusion in tflite."
+)
+class OpHint:
+  """A class that helps build tflite function invocations.
+
+  It allows you to take a bunch of TensorFlow ops and annotate the construction
+  such that toco knows how to convert it to tflite. This embeds a pseudo
+  function in a TensorFlow graph. This allows embedding high-level API usage
+  information in a lower level TensorFlow implementation so that an alternative
+  implementation can be substituted later.
+
+  Essentially, any "input" into this pseudo op is fed into an identity, and
+  attributes are added to that input before being used by the constituent ops
+  that make up the pseudo op. A similar process is done to any output that
+  is to be exported from the current op.
+
+  """
+  # Attr constants that are used for representation in the GraphDef. These
+  # will be used on every Identity op that is involved in a total OpHint.
+
+  # Name of the OpHint function (cosmetic).
+  FUNCTION_NAME_ATTR = "_tflite_function_name"
+  # UUID of the function (each OpHint gets a new uuid).
+  FUNCTION_UUID_ATTR = "_tflite_function_uuid"
+  # The input index of the input (or nothing if it is an output).
+  FUNCTION_INPUT_INDEX_ATTR = "_tflite_function_input_index"
+  # The output index of the output (or nothing if it is an input).
+  FUNCTION_OUTPUT_INDEX_ATTR = "_tflite_function_output_index"
+  # An index that orders aggregate arguments. Aggregate arguments are ones
+  # that are separate but will be fused horizontally. For example a static LSTM
+  # has a lstm cell for each time step. Each one has a separate opHint, but a
+  # fused SequentialLSTM will treat this as a single tensor.
+  FUNCTION_SORT_INDEX_ATTR = "_tflite_function_sort_index"
+  # The way in which multiple parts of the aggregate argument will be joined
+  # into a fused operand. Valid options are OpHint.AGGREGATE_FIRST,
+  # OpHint.AGGREGATE_LAST, OpHint.AGGREGATE_STACK.
+  FUNCTION_AGGREGATE_ATTR = "_tflite_function_aggregate"
+  # On fused OpHint stub, the order of inputs that the final LSTM call will
+  # have. What this means is that the TensorFlow order might be
+  # "foo", "bar", "stuff" and you might want the TF lite op order to be
+  # "stuff", "foo", "bar", -1 (where -1 is unused). So you would set this
+  # attribute to [2, 0, 1, -1].
+  TFLITE_INPUT_INDICES = "_tflite_input_indices"
+  # OpHint level.
+  FUNCTION_LEVEL_ATTR = "_tflite_ophint_level"
+  # Ophint internal mapping, this is for high level Ophint only.
+  # This basically contains three kinds of mapping:
+  #   1) How parental ophinted inputs map to the first child ophinted inputs;
+  #   2) How internal children nodes are connected;
+  #   3) How parental ophinted outputs map to the last child ophinted outputs.
+  CHILDREN_INPUTS_MAPPINGS = "_tflite_children_ophint_inputs_mapping"
+
+  # Types of aggregations
+  #  stack: stacks all ophints with matching tags. i.e. for a static rnn.
+  #   specifically, this is good for an input or output to a static rnn cell.
+  AGGREGATE_STACK = "stack"
+  # first: only takes the first output (one with lowest sort index)
+  # of matching tags. This is good for the input state to an RNN.
+  AGGREGATE_FIRST = "first"
+  # aggregation last takes only the last tag (one with highest sort index).
+  # This is good for an output value on the last stack item of a
+  # static rnn.
+  AGGREGATE_LAST = "last"
+
+  class OpHintArgumentTracker:
+    """Conceptually tracks indices of arguments of "OpHint functions".
+
+    The inputs and arguments of these functions both use an instance
+    of the class so they can have independent numbering.
+    """
+
+    def __init__(self,
+                 function_name,
+                 unique_function_id,
+                 node_name_prefix,
+                 attr_name,
+                 level=1,
+                 children_inputs_mappings=None):
+      """Initialize ophint argument.
+
+      Args:
+        function_name: Name of the function that this tracks arguments for.
+        unique_function_id: UUID of function that this tracks arguments for.
+        node_name_prefix: How identities that are created are named.
+        attr_name: Name of attribute to use to store the index for this hint.
+          i.e. FUNCTION_INPUT_INDEX or FUNCTION_OUTPUT_INDEX
+        level: Hierarchical level of the Ophint node, a number.
+        children_inputs_mappings: Inputs/Outputs mapping for children hints.
+      """
+
+      # The global index is the argument index of the op. This is in contrast
+      # to the sort index which is the sequence number of a particular instance
+      # of a given global index. For example, you may have called add hint
+      # twice with the tag "foo". Then the global index will be 0 for both
+      # and the sort index will be 0 for the first added and 1 for the second.
+      self._function_name = function_name
+      self._unique_function_id = unique_function_id
+      self._next_global_index = 0  # The absolute global index
+      self._used_global_indices = set()
+      self._tag_to_global_index = {}  # The argument index a given tag maps to
+      self._tag_to_next_sort_index = {}  # The current index for each tag
+      self._node_name_prefix = node_name_prefix
+      self._attr_name = attr_name
+      self._level = level
+      self._children_inputs_mappings = children_inputs_mappings
+
+    def _get_new_global_index(self, index_override):
+      """Return the next unused argument index in order or use an override.
+
+      Args:
+        index_override: An index to use instead of the next available or None
+          to use the next available.
+
+      Returns:
+        A valid global_index to use for the next hint argument.
+
+      Raises:
+        ValueError: If the index_override is already used by another hint.
+      """
+      if index_override is None:
+        global_index = self._next_global_index
+      else:
+        if index_override in self._used_global_indices:
+          raise ValueError("Index %d was already used by another call to add")
+        global_index = index_override
+      # Make next_global_index valid
+      self._used_global_indices.add(global_index)
+      while self._next_global_index in self._used_global_indices:
+        self._next_global_index += 1
+      return global_index
+
+    def add(self, arg, tag=None, name=None, aggregate=None,
+            index_override=None):
+      """Return a wrapped tensor of an input tensor as an argument.
+
+      Args:
+        arg: A TensorFlow tensor that should be considered an argument.
+        tag: String tag to identify arguments that should be packed.
+        name: Name of argument. This is included in the Identity hint op names.
+        aggregate: Strategy to aggregate.
+        Acceptable values are OpHint.AGGREGATE_FIRST, OpHint.AGGREGATE_LAST,
+          and OpHint.AGGREGATE_STACK.
+          Note, aggregate is only valid if tag is specified.
+        index_override: Specify what input/output index should this be in the
+          final stub. i.e. add(arg0, index=1); add(arg1, index=0) will make the
+          final stub be as stub_func(inputs[arg1, arg0], outputs=[]) rather than
+          the default call order based ordering.
+
+      Returns:
+        A tensor representing the wrapped argument.
+
+      Raises:
+        ValueError: When indices are not consistent.
+      """
+
+      # Find the appropriate index
+      if tag is None:
+        if aggregate is not None:
+          raise ValueError("You must specify `tag` if using aggregate.")
+        global_index = self._get_new_global_index(index_override)
+        sort_index = None
+      else:
+        if aggregate is None:
+          raise ValueError("You must specify `aggregate` if using tag.")
+        if tag not in self._tag_to_global_index:
+          self._tag_to_global_index[tag] = (
+              self._get_new_global_index(index_override))
+          self._tag_to_next_sort_index[tag] = 0
+        elif (index_override and
+              index_override != self._tag_to_global_index[tag]):
+          raise ValueError(
+              "Tag %r was called with two indices %r and %r" %
+              (tag, index_override, self._tag_to_global_index[tag]))
+        global_index = self._tag_to_global_index[tag]
+        sort_index = self._tag_to_next_sort_index[tag]
+        self._tag_to_next_sort_index[tag] += 1
+
+      uuid = self._unique_function_id
+      name = "%s-%s-%s-%r-%r-%s" % (self._node_name_prefix, self._function_name,
+                                    uuid, global_index, sort_index, name)
+
+      identity_op = _array_ops.identity(arg, name=name)
+
+      # pylint: disable=protected-access
+      identity_op.op._set_attr(
+          OpHint.FUNCTION_NAME_ATTR,
+          _attr_value_pb2.AttrValue(
+              s=_compat.as_bytes(self._function_name)))
+      identity_op.op._set_attr(
+          OpHint.FUNCTION_UUID_ATTR,
+          _attr_value_pb2.AttrValue(
+              s=_compat.as_bytes(self._unique_function_id)))
+      identity_op.op._set_attr(
+          self._attr_name, _attr_value_pb2.AttrValue(i=global_index))
+      identity_op.op._set_attr(OpHint.FUNCTION_LEVEL_ATTR,
+                               _attr_value_pb2.AttrValue(i=self._level))
+      if self._children_inputs_mappings:
+        identity_op.op._set_attr(
+            OpHint.CHILDREN_INPUTS_MAPPINGS,
+            _attr_value_pb2.AttrValue(
+                s=_compat.as_bytes(_json.dumps(
+                    self._children_inputs_mappings))))
+
+      if sort_index is not None:
+        identity_op.op._set_attr(
+            OpHint.FUNCTION_SORT_INDEX_ATTR,
+            _attr_value_pb2.AttrValue(i=sort_index))
+      if aggregate is not None:
+        identity_op.op._set_attr(
+            OpHint.FUNCTION_AGGREGATE_ATTR,
+            _attr_value_pb2.AttrValue(s=_compat.as_bytes((aggregate))))
+      # pylint: enable=protected-access
+      return identity_op
+
+  def __init__(self,
+               function_name,
+               level=1,
+               children_inputs_mappings=None,
+               **kwargs):
+    """Create a OpHint.
+
+    Args:
+      function_name: Name of the function (the custom op name in tflite)
+      level: OpHint level.
+      children_inputs_mappings: Children OpHint inputs/outputs mapping.
+        children_inputs_mappings should like below:
+        "parent_first_child_input":
+            [{"parent_input_index": num, "child_input_index": num}, ...]
+        "parent_last_child_output":
+            [{"parent_output_index": num, "child_output_index": num}, ...]
+        "internal_children_input_output":
+            [{"child_input_index": num, "child_output_index": num}, ...]
+      **kwargs: Keyword arguments of any constant attributes for the function.
+    """
+    self._function_name = function_name
+    self._level = level
+    if self._level == 1:
+      assert children_inputs_mappings is None
+    else:
+      assert isinstance(children_inputs_mappings, dict)
+    self._children_inputs_mappings = children_inputs_mappings
+    if self._children_inputs_mappings is not None:
+      self._validate_children_inputs_mappings(self._children_inputs_mappings)
+    self._unique_function_id = _uuid.uuid1().hex
+    self._attrs_to_store_later = kwargs
+    self._stored_attrs = False
+    self._inputs = OpHint.OpHintArgumentTracker(
+        self._function_name, self._unique_function_id, "InputHint",
+        OpHint.FUNCTION_INPUT_INDEX_ATTR, level, self._children_inputs_mappings)
+    self._outputs = OpHint.OpHintArgumentTracker(
+        self._function_name, self._unique_function_id, "OutputHint",
+        OpHint.FUNCTION_OUTPUT_INDEX_ATTR, level,
+        self._children_inputs_mappings)
+
+  def _validate_children_inputs_mappings(self, children_inputs_mappings):
+    """Validate children inputs mappings is in the right format.
+
+    Args:
+      children_inputs_mappings: the Children ophint inputs/outputs mapping.
+    """
+    assert isinstance(children_inputs_mappings, dict)
+    assert "parent_first_child_input" in children_inputs_mappings
+    assert "parent_last_child_output" in children_inputs_mappings
+    assert "internal_children_input_output" in children_inputs_mappings
+
+    # validate parent_first_child_input.
+
+    def assert_dictlist_has_keys(dictlist, keys):
+      for dikt in dictlist:
+        assert isinstance(dikt, dict)
+        for key in keys:
+          assert key in dikt
+
+    assert_dictlist_has_keys(
+        children_inputs_mappings["parent_first_child_input"],
+        ["parent_ophint_input_index", "first_child_ophint_input_index"])
+    assert_dictlist_has_keys(
+        children_inputs_mappings["parent_last_child_output"],
+        ["parent_output_index", "child_output_index"])
+    assert_dictlist_has_keys(
+        children_inputs_mappings["internal_children_input_output"],
+        ["child_input_index", "child_output_index"])
+
+  def _setattr(self, dest_op, name, value):
+    tensor_value = _ops.convert_to_tensor(value)
+    # pylint: disable=protected-access
+    dest_op.op._set_attr(name, _attr_value_pb2.AttrValue(
+        tensor=tensor_value.op.node_def.attr["value"].tensor))
+    # pylint: enable=protected-access
+
+  def add_input(self, *args, **kwargs):
+    """Add a wrapped input argument to the hint.
+
+    Args:
+      *args: The input tensor.
+      **kwargs:
+        "name" label
+        "tag" a tag to group multiple arguments that will be aggregated. I.e.
+          a string like 'cool_input'. Basically multiple inputs can be added
+          to the same hint for parallel operations that will eventually be
+          combined. An example would be static_rnn which creates multiple copies
+          of state or inputs.
+        "aggregate" aggregation strategy that is valid only for tag non None.
+          Acceptable values are OpHint.AGGREGATE_FIRST, OpHint.AGGREGATE_LAST,
+          and OpHint.AGGREGATE_STACK.
+        "index_override" The global index to use. This corresponds to the
+          argument order in the final stub that will be generated.
+    Returns:
+      The wrapped input tensor.
+    """
+    return self._inputs.add(*args, **kwargs)
+
+  def add_output(self, *args, **kwargs):
+    """Add a wrapped output argument to the hint.
+
+    Args:
+      *args: The output tensor.
+      **kwargs:
+        "name" label
+        "tag" a tag to group multiple arguments that will be aggregated. I.e.
+          a string like 'cool_input'. Basically multiple inputs can be added
+          to the same hint for parallel operations that will eventually be
+          combined. An example would be static_rnn which creates multiple copies
+          of state or inputs.
+        "aggregate" aggregation strategy that is valid only for tag non None.
+          Acceptable values are OpHint.AGGREGATE_FIRST, OpHint.AGGREGATE_LAST,
+          and OpHint.AGGREGATE_STACK.
+        "index_override" The global index to use. This corresponds to the
+          argument order in the final stub that will be generated.
+    Returns:
+      The wrapped output tensor.
+    """
+    return self._outputs.add(*args, **kwargs)
+
+  def add_inputs(self, *args, **kwargs):
+    """Add a sequence of inputs to the function invocation.
+
+    Args:
+      *args: List of inputs to be converted (should be Tf.Tensor).
+      **kwargs: This allows 'names' which should be a list of names.
+
+    Returns:
+      Wrapped inputs (identity standins that have additional metadata). These
+      are also are also tf.Tensor's.
+    """
+    if "names" in kwargs:
+      return [
+          self._inputs.add(arg, name=name)
+          for arg, name in zip(args, kwargs["names"])
+      ]
+    else:
+      return [self._inputs.add(arg) for arg in args]
+
+  def add_outputs(self, *args, **kwargs):
+    """Add a sequence of outputs to the function invocation.
+
+    Args:
+      *args: List of outputs to be converted (should be tf.Tensor).
+      **kwargs: See
+
+    Returns:
+      Wrapped outputs (identity standins that have additional metadata). These
+      are also tf.Tensor's.
+    """
+    if "names" in kwargs:
+      return [
+          self._outputs.add(arg, name=name)
+          for arg, name in zip(args, kwargs["names"])
+      ]
+    else:
+      return [self._outputs.add(arg) for arg in args]
+
+
+class _LiteOperand:
+  """Abstract operand for a tflite hint function._dynamic_rnn_loop.
+
+  This is a base class that handles representing arguments to an OpHint.
+  It also is able to serialize operands to the stubbed graph_def.
+  Child classes are responsible for being able to
+  store information about the hint identity operators. They are also responsible
+  for knowing how to serialize to output graphdefs.
+
+  Typically this will be implemented by holding one or more identity nodes
+  that were previously discovered as hints.
+  """
+
+  def aggregate_and_return_name_for_input(self, out_graphdef):
+    """This adds the node(s) to out_graphdef and returns the input node name.
+
+    Args:
+      out_graphdef: A graphdef that is ready to have this input added.
+
+    Returns:
+      The output that the stub should use as an input for this operand.
+
+    Raises:
+      RuntimeError: if the method is not implemented.
+    """
+    del out_graphdef
+    raise RuntimeError("Unimplemented abstract method.")
+
+  def aggregate_and_return_name_for_output(self, fused_op_name, output_index,
+                                           out_graphdef):
+    """Add node(s) to graph representing output operands and returns type.
+
+    Args:
+      fused_op_name: name of the fused op stub name.
+      output_index: Output index that we are currently processing from stub.
+      out_graphdef: The destination graphdef we are currently building up.
+
+    Returns:
+      The datatype of this identity.
+
+    Raises:
+      RuntimeError: if the method is not implemented.
+    """
+    del fused_op_name, output_index, out_graphdef
+    raise RuntimeError("Unimplemented abstract method.")
+
+
+class _LiteSingleOperand(_LiteOperand):
+  """A simple operand that is non-aggregated (i.e. most hints)."""
+
+  def __init__(self, node):
+    _LiteOperand.__init__(self)
+    self.node = node
+    self.name = _tensor_name_base(node.name)
+
+  def flatten(self):
+    return [self.name]
+
+  def aggregate_and_return_name_for_input(self, out_graphdef):
+    return self.name
+
+  def aggregate_and_return_name_for_output(self, fused_op_name, index,
+                                           out_graphdef):
+    output_node = _copy.deepcopy(self.node)
+    del output_node.input[:]
+    output_node.input.append(_tensorflow_output_name(fused_op_name, index))
+    out_graphdef.node.extend([output_node])
+    return self.node.attr["type"].i
+
+  def __str__(self):
+    return str(self.name)
+
+
+class _LiteAggregateOperand(_LiteOperand):
+  """An operand for a tflite hint function that is aggregated from many.
+
+  For example, an LSTM is a grid of operators that are all related. Inputs
+  going into them may need to be fused, so they should all be tracked as
+  related arguments.
+  """
+
+  def __init__(self, aggregation):
+    _LiteOperand.__init__(self)
+    self.aggregation = aggregation
+    self.names = {}
+    self.nodes = {}
+    self.flattened = None
+
+  def add(self, sort, node):
+    self.names[sort] = _tensor_name_base(node.name)
+    self.nodes[sort] = node
+
+  def flatten_nodes(self):
+    """Return a list of all the node protos in aggregation sorted order."""
+    if not self.flattened:
+      self.flattened = [None] * len(self.nodes)
+      for idx, node in self.nodes.items():
+        self.flattened[idx] = node
+      for n in self.nodes:
+        if n is None:
+          raise RuntimeError("Aggregate was missing argument.")
+      if self.aggregation == OpHint.AGGREGATE_FIRST:
+        self.flattened = self.flattened[:1]
+      elif self.aggregation == OpHint.AGGREGATE_LAST:
+        self.flattened = self.flattened[-1:]
+      elif self.aggregation == OpHint.AGGREGATE_STACK:
+        pass
+      else:
+        raise ValueError("Invalid aggregation type %r specified" %
+                         self.aggregation)
+    return self.flattened
+
+  def flatten(self):
+    """Return a list of all node names in aggregation sorted sorter."""
+    return [_tensor_name_base(x.name) for x in self.flatten_nodes()]
+
+  def aggregate_and_return_name_for_input(self, out_graphdef):
+    """This adds the nodes to out_graphdef and returns an aggregated output.
+
+    In particular, if you have 4 inputs to a hint stub, this will be the
+    node that you can use as an output. I.e. you have 4 timesteps from a
+    static rnn, then a fused UnidirectionalLSTM will expect 1 input with
+    all 4 time steps. So here we make a pack and return the output name of
+    that pack.
+
+    Args:
+      out_graphdef: A graphdef that is ready to have this input added.
+
+    Returns:
+      The name of a pack that aggregates this node.
+    """
+    flattened = self.flatten_nodes()
+    if (self.aggregation == OpHint.AGGREGATE_FIRST) or (
+        self.aggregation == OpHint.AGGREGATE_LAST):
+      assert len(flattened) == 1
+    if len(flattened) == 1 and self.aggregation != OpHint.AGGREGATE_STACK:
+      return _tensor_name_base(flattened[0].name)
+    else:
+      new_node = _node_def_pb2.NodeDef()
+      new_node.op = "Pack"
+      new_node.name = "OpHintStack-%s" % flattened[0].name
+      new_node.attr["N"].i = len(flattened)
+      new_node.attr["T"].type = flattened[0].attr["T"].type
+      for discrete in flattened:
+        new_node.input.append(_tensor_name_base(discrete.name))
+      out_graphdef.node.extend([new_node])
+      return new_node.name
+
+  def aggregate_and_return_name_for_output(self, fused_op_name, output_index,
+                                           out_graphdef):
+    """This adds to `out_graphdef` all the unaggregated outputs.
+
+    I.e. we are outputting from a fused stub, but we need to make it compatible
+    with the unfused original graph so we insert an unpack. Ideally in a later
+    stage the unpack -> pack sequences will be removed.
+
+    Args:
+      fused_op_name: The name of the stub we are in the process of fusing.
+      output_index: The output output_index this object represents.
+      out_graphdef: The graphdef we are in the process of buildings
+
+    Returns:
+      The type of the aggregated output (so we can finish building the stub
+      op).
+    """
+    flattened = self.flatten_nodes()
+    if (self.aggregation == OpHint.AGGREGATE_FIRST) or (
+        self.aggregation == OpHint.AGGREGATE_LAST):
+      assert len(flattened) == 1
+    if len(flattened) == 1 and self.aggregation != OpHint.AGGREGATE_STACK:
+      temp_op = _LiteSingleOperand(flattened[0])
+      return temp_op.aggregate_and_return_name_for_output(
+          fused_op_name, output_index, out_graphdef)
+    else:
+      stack_node = _node_def_pb2.NodeDef()
+      stack_node.op = "Unpack"
+      stack_node.name = "OpHintUnstack-%s" % flattened[0].name
+      stack_node.attr["num"].i = len(flattened)
+      output_type = flattened[0].attr["T"].type
+      stack_node.attr["T"].type = output_type
+      stack_node.input.append(
+          _tensorflow_output_name(fused_op_name, output_index))
+      out_graphdef.node.extend([stack_node])
+
+      for idx, discrete in enumerate(flattened):
+        output_node = _copy.deepcopy(discrete)
+        del output_node.input[:]
+        output_node.input.append(_tensorflow_output_name(stack_node.name, idx))
+        out_graphdef.node.extend([output_node])
+
+      return output_type
+
+  def __str__(self):
+    s = "\t\t\tAGGREGATE %s\n" % self.aggregation
+    for sort, val in self.names.iteritems():
+      s += "\t\t\t%d: %s\n" % (sort, val)
+    return s
+
+
+class _LiteFuncCall:
+  """Represent a TensorFlow Lite custom function.
+
+  This is uses to accumulate found hints in the graphdef into a single
+  conceptual unit.
+
+  Attributes:
+    inputs: inputs to the op (hash from index # to argument)
+    outputs: outputs to the op (hash from index # to argument)
+    function_name: the tflite custom op name to use
+    uuid: a unique call id for this particular call  (i.e. multiple function
+      calls would have the same function_name but different uuids.
+    params: A param name to key value for op constant data. I.e. for axis on a
+      reduction, strides on a convolution, etc.
+    level: Level of the OpHint.
+    children_inputs_mappings: If the Ophint has children, children inputs
+      mappings indicate how their inputs & outputs are mapped.
+  """
+
+  def __init__(self):
+    self.inputs = {}
+    self.outputs = {}
+    self.function_name = None
+    self.uuid = None
+    self.params = {}
+    self.level = -1
+    self.children_inputs_mappings = {}
+
+  def flattened_inputs_and_outputs(self):
+    """Return a list of inputs and outputs in a flattened format.
+
+    Returns:
+      Tuple of (inputs, outputs). where input and output i a list of names.
+    """
+
+    def _flatten(input_or_output_dict):
+      flattened_items = []
+      for item in input_or_output_dict.values():
+        flattened_items.extend(item.flatten())
+      return flattened_items
+
+    return _flatten(self.inputs), _flatten(self.outputs)
+
+  def __str__(self):
+
+    def format_args(items):
+      s = ""
+      for idx, item in items.iteritems():
+        s += ("\t\t%d:\n" % idx) + str(item)
+      return s
+
+    inputs_str = "\tInputs\n" + format_args(self.inputs)
+    outputs_str = "\tOutputs\n" + format_args(self.outputs)
+
+    return (
+        "tflite function %s call %s level %d "
+        "\n\tinputs:\n\t\t%s\n\toutputs:\n\t\t%s" %
+        (self.function_name, self.uuid, self.level, inputs_str, outputs_str))
+
+
+def _find_all_hints_in_nodes(nodes):
+  """Look at the all the input nodes and return a list of LiteFuncCall objs.
+
+  Args:
+    nodes: A TensorFlow graph_def to look for LiteFuncCalls.
+
+  Returns:
+    a list of `LifeFuncCall` objects in the form
+
+  """
+  func_calls = _collections.defaultdict(_LiteFuncCall)
+
+  for node in nodes:
+    attr = node.attr
+    # This is an op hint if it has a FUNCTION_UUID_ATTR, otherwise skip
+    if (OpHint.FUNCTION_UUID_ATTR not in attr or
+        not attr[OpHint.FUNCTION_UUID_ATTR].s):
+      continue
+    uuid = attr[OpHint.FUNCTION_UUID_ATTR].s
+
+    # Start building function
+    call_def = func_calls[uuid]
+    call_def.uuid = uuid
+    call_def.function_name = attr[OpHint.FUNCTION_NAME_ATTR].s
+    call_def.level = attr[OpHint.FUNCTION_LEVEL_ATTR].i
+    # Get sorting and aggregation information
+
+    sort = (
+        attr[OpHint.FUNCTION_SORT_INDEX_ATTR].i
+        if OpHint.FUNCTION_SORT_INDEX_ATTR in attr else None)
+    if sort == -1:
+      sort = None
+    aggregation = None
+    if OpHint.FUNCTION_AGGREGATE_ATTR in attr:
+      aggregation = _compat.as_text(attr[OpHint.FUNCTION_AGGREGATE_ATTR].s)
+
+    if OpHint.CHILDREN_INPUTS_MAPPINGS in attr:
+      call_def.children_inputs_mappings = _json.loads(
+          _compat.as_text(attr[OpHint.CHILDREN_INPUTS_MAPPINGS].s))
+
+    # Add the input or output
+    def put_operand(stuff, index, sort, operand, aggregation):
+      """Add a given index into the function structure."""
+      if sort is None:
+        stuff[index] = _LiteSingleOperand(operand)
+      else:
+        if index not in stuff:
+          stuff[index] = _LiteAggregateOperand(aggregation)
+        stuff[index].add(sort, operand)
+
+    if OpHint.FUNCTION_INPUT_INDEX_ATTR in attr:
+      put_operand(call_def.inputs, attr[OpHint.FUNCTION_INPUT_INDEX_ATTR].i,
+                  sort, node, aggregation)
+    if OpHint.FUNCTION_OUTPUT_INDEX_ATTR in attr:
+      put_operand(call_def.outputs, attr[OpHint.FUNCTION_OUTPUT_INDEX_ATTR].i,
+                  sort, node, aggregation)
+
+    # Remember attributes
+    for a in attr:
+      if a.startswith("_tflite_attr_"):
+        call_def.params[a.replace("_tflite_attr_,", "")] = attr[a].tensor
+
+  return func_calls
+
+
+def _extract_topology_sequence_mapping(nodes):
+  return dict(
+      (_tensor_name_base(node.name), idx) for idx, node in enumerate(nodes))
+
+
+def _find_children_hints_in_while_loop(function_def, nodes_mapping):
+  """Find children hints and all nodes inside the while loop.
+
+  Args:
+    function_def: Function def of the while loop.
+    nodes_mapping: While loop input_arg : real node name.
+
+  Returns:
+    Ordered children hints and all re-mapped nodes inside the while loop.
+  """
+  new_nodes = []
+
+  # Make nodes inside function def inputs point to the real nodes.
+  for node in function_def.node_def:
+    for i, _ in enumerate(node.input):
+      if node.input[i] in nodes_mapping:
+        node.input[i] = nodes_mapping[node.input[i]]
+    new_nodes.append(_copy.deepcopy(node))
+  name_to_seq_num = _extract_topology_sequence_mapping(function_def.node_def)
+  children_hints = _find_all_hints_in_nodes(new_nodes)
+  children_hints_q = []
+  # Ordered by the outputs.
+  for hint in children_hints.values():
+    _, output_names = hint.flattened_inputs_and_outputs()
+    seq = name_to_seq_num[output_names[0]]
+    for output_name in output_names:
+      seq = min(seq, name_to_seq_num[output_name])
+    children_hints_q.append((seq, hint))
+  children_hints_q.sort(key=lambda tup: tup[0])
+  ordered_children_hints = [x[1] for x in children_hints_q]
+  return ordered_children_hints, new_nodes
+
+
+def _find_children_hints(call, graph_def):
+  """Find all children hints.
+
+  For a given OpHint, we find all children hints inside it, we also copy all the
+  nodes inside function defs (if applicable) to the original graph_def, they are
+  returned in a list as well.
+
+  Args:
+    call: Parent OpHint that contains children ophints.
+    graph_def: Original graph def.
+
+  Returns:
+    Ordered children hints inside the parent ophint; new graph def that contains
+    nodes inside function defs (if applicable); nodes inside function defs.
+  """
+  name_to_input_name, _, _ = _extract_graph_summary(graph_def)
+  input_names, output_names = call.flattened_inputs_and_outputs()
+
+  reachable_by_input = _bfs_for_reachable_nodes(input_names, name_to_input_name)
+  reachable_by_output = _bfs_for_reachable_nodes(output_names,
+                                                 name_to_input_name)
+  output_nodes_set = set(output_names)
+  children_hints = []
+  out = _graph_pb2.GraphDef()
+  out.library.CopyFrom(graph_def.library)
+  out.versions.CopyFrom(graph_def.versions)
+  function_def_nodes = set()
+  for node in graph_def.node:
+    out.node.extend([_copy.deepcopy(node)])
+    n = _tensor_name_base(node.name)
+    if n in reachable_by_output:
+      if n not in reachable_by_input and n not in output_nodes_set:
+        # special handle for while loop function def.
+        if node.op == "While" or node.op == "StatelessWhile":
+          body_name = node.attr["body"].func.name
+          inputs_outside_loop = node.input
+          for function_def in graph_def.library.function:
+            if function_def.signature.name == body_name:
+              function_inputs = function_def.signature.input_arg
+              assert len(inputs_outside_loop) == len(function_inputs)
+              nodes_mapping = {}
+              for i, function_input in enumerate(function_inputs):
+                nodes_mapping[function_input.name] = inputs_outside_loop[i]
+              (children_hints_in_loop,
+               new_nodes) = _find_children_hints_in_while_loop(
+                   function_def, nodes_mapping)
+              function_def_nodes.update([x.name for x in new_nodes])
+              children_hints.extend(children_hints_in_loop)
+              out.node.extend(new_nodes)
+
+  return children_hints, out, function_def_nodes
+
+
+def _tensor_name_base(full_tensor_name):
+  """Removes the device assignment code from a tensor.
+
+  e.g. _tensor_name_base("foo:3") => "foo"
+
+  Args:
+    full_tensor_name: A tensor name that is annotated with a device placement
+      (this is what tensor flow introspection gives).
+
+  Returns:
+    A name without any device assignment.
+  """
+  if full_tensor_name.startswith("^"):
+    return full_tensor_name[1:]
+  return full_tensor_name.split(":")[0]
+
+
+def _tensorflow_output_name(tensor_name, output_index):
+  return tensor_name if output_index == 0 else "%s:%d" % (tensor_name,
+                                                          output_index)
+
+
+def _check_subgraph_closed(n, reachable_by_input, input_nodes_set,
+                           name_to_input_name):
+  """Checks to make sure node only connects to predecessor graph through inputs.
+
+  Args:
+    n: Node to check
+    reachable_by_input: Nodes that are reachable by all inputs of subgraph
+    input_nodes_set: The set of nodes that are "inputs".
+    name_to_input_name: Maps from name to the list of inputs.
+
+  Raises:
+    TypeError: If the given node uses items past inputs directly.
+  """
+  next_to_visit = [n]
+  visited = set()
+  while next_to_visit:
+    current_node = next_to_visit.pop()
+    visited.add(current_node)
+    if (current_node in reachable_by_input and
+        current_node not in input_nodes_set):
+      raise TypeError("Node %s uses input %s not in input_nodes." %
+                      (n, current_node))
+    if current_node not in input_nodes_set:
+      next_to_visit += [
+          input_node for input_node in name_to_input_name[current_node]
+          if input_node not in visited
+      ]
+
+
+def _convert_single_op_hint_to_stub(call,
+                                    graph_def,
+                                    function_def_nodes=None,
+                                    is_last_run=True):
+  """Given a graph_def, converts `call` into a stub and returns a new graph_def.
+
+  Args:
+    call: A single function call to be converted.
+    graph_def: A graph_def to use as input (that has call obviously).
+    function_def_nodes: Nodes inside the function def those are not connected to
+      the graph.
+    is_last_run: Whether it is the last run for a given pass (for OpHint has
+      children).
+
+  Returns:
+    A new transformed graph-def that has call as a stub (single op).
+
+  Note: after this process, the graph_def can no longer be loaded into
+      the tensorflow runtime, so all future manipulations are done in graph_def
+      level.
+  """
+  if function_def_nodes is None:
+    function_def_nodes = set()
+  name_to_input_name, name_to_node, name_to_seq_num = _extract_graph_summary(
+      graph_def)
+  input_names, output_names = call.flattened_inputs_and_outputs()
+
+  reachable_by_input = _bfs_for_reachable_nodes(input_names, name_to_input_name)
+  reachable_by_output = _bfs_for_reachable_nodes(output_names,
+                                                 name_to_input_name)
+  output_nodes_set = set(output_names)
+  nodes_after_fuse = []
+  nodes_deleted_by_fuse = set()
+  # Classify each node. We want to keep everything reachable by input, but
+  # we don't know if things that are not reachable by output or input (things
+  # after fusing).
+  for node in graph_def.node:
+    n = _tensor_name_base(node.name)
+    if n in reachable_by_output:
+      if n not in reachable_by_input and n not in output_nodes_set:
+        nodes_deleted_by_fuse.add(n)
+    elif n not in reachable_by_input and n not in function_def_nodes:
+      # n is a node that after all the fusings, so keep it.
+      nodes_after_fuse.append(n)
+    else:
+      # In the last run, n is a node that is randomly in the graph but not
+      # connected to the chain of dependencies, we will delete n, otherwise
+      # we keep them.
+      if not is_last_run:
+        nodes_after_fuse.append(n)
+
+  # Make a new graphdef with all the pre-input and input nodes
+  out = _graph_pb2.GraphDef()
+  reachable_by_input_sorted = sorted(
+      list(reachable_by_input), key=lambda n: name_to_seq_num[n])
+  for node in reachable_by_input_sorted:
+    out.node.extend([_copy.deepcopy(name_to_node[node])])
+
+  # Create any stacks to aggregate arguments into to a single input
+  # i.e. for static_rnn's.
+  sorted_input_indices = list(call.inputs.keys())
+  sorted_input_indices.sort()
+  sorted_output_indices = list(call.outputs.keys())
+  sorted_output_indices.sort()
+  new_node = _node_def_pb2.NodeDef()
+  # Delegate to each operand to produce the proper new input for this stub node.
+  # In particular, an aggregate input will now be a Pack of some previously
+  # non-fused things.
+
+  optional_input_node = _node_def_pb2.NodeDef()
+  optional_input_node.name = "Const" + str(_uuid.uuid1().hex)
+  optional_input_node.op = "Const"
+  optional_input_node.attr["dtype"].CopyFrom(
+      _attr_value_pb2.AttrValue(type=_dtypes.float32.as_datatype_enum))
+  optional_input_node.attr["value"].CopyFrom(
+      _attr_value_pb2.AttrValue(
+          tensor=_tensor_util.make_tensor_proto([-1], _dtypes.float32, [1])))
+  out.node.extend([optional_input_node])
+
+  max_index = max(sorted_input_indices) + 1
+  for cur_index in range(max_index):
+    if cur_index in sorted_input_indices:
+      inputs = call.inputs[cur_index]
+      input_name = inputs.aggregate_and_return_name_for_input(out)
+      new_node.input.append(input_name)
+    else:
+      new_node.input.append(optional_input_node.name)
+
+  new_node.attr[OpHint.TFLITE_INPUT_INDICES].list.i.extend(sorted_input_indices)
+
+  # Create the function
+  new_node.op = call.function_name
+  new_node.name = call.uuid
+  out.node.extend([new_node])
+
+  # Now call each output argument to give them a chance to make the proper
+  # output type and add it to our new_node.
+  output_dtypes = []
+  max_output_index = max(sorted_output_indices) + 1
+  for cur_index in range(max_output_index):
+    if cur_index in sorted_output_indices:
+      output = call.outputs[cur_index]
+      output_dtype = (
+          output.aggregate_and_return_name_for_output(new_node.name, cur_index,
+                                                      out))
+    else:
+      output_dtype = optional_input_node.attr["type"].i
+    output_dtypes.append(output_dtype)
+  new_node.attr["_output_types"].list.type[:] = output_dtypes
+  new_node.attr["_output_quantized"].b = False
+
+  # Add post output nodes that do not depend on the outputs
+  for n in nodes_after_fuse:
+    should_keep = True
+    for input_name in name_to_input_name[n]:
+      if input_name in nodes_deleted_by_fuse:
+        should_keep = False
+    if should_keep:
+      out.node.extend([_copy.deepcopy(name_to_node[n])])
+
+  # Misc. graph_def data that needs copying.
+  out.library.CopyFrom(graph_def.library)
+  out.versions.CopyFrom(graph_def.versions)
+
+  return out
+
+
+def _remove_one_redundant_stack_unstack(in_graph_def):
+  """Removes a stack->unstack pattern from in_graph_def in a returned graph.
+
+  Args:
+    in_graph_def: Graph def to use as input.
+
+  Returns:
+    Simplified tuple (graph_def, changed_something) where changed_something
+    is true if anything was done.
+  """
+  name_to_input_name, name_to_node, name_to_seq_num = _extract_graph_summary(
+      in_graph_def)
+  del name_to_seq_num
+
+  do_generic_pack_unpack = True
+
+  out = _graph_pb2.GraphDef()
+  out.library.CopyFrom(in_graph_def.library)
+  out.versions.CopyFrom(in_graph_def.versions)
+  for n in in_graph_def.node:
+    node_name = _tensor_name_base(n.name)
+    if not node_name.startswith("OpHintStack") and not n.op.startswith("Pack"):
+      continue
+    next_to_visit = [node_name]
+    visited = set()
+
+    unpack_nodes = set()
+    pack_node = node_name
+
+    # Find a pattern of unstack connected to a stack (with identities
+    # in between.
+    matches_pattern = True
+    is_hint_created_stack = False
+    while next_to_visit:
+      current_node_name = next_to_visit[0]
+      visited.add(current_node_name)
+      del next_to_visit[0]
+      node = name_to_node[current_node_name]
+      is_op_hint_stack = node.name.startswith("OpHintStack")
+      is_op_hint_unstack = node.name.startswith("OpHintUnstack")
+      if (node.op == "Identity" or is_op_hint_stack or
+          (do_generic_pack_unpack and node.op == "Pack")):
+        is_hint_created_stack |= is_op_hint_stack
+        next_to_visit += [
+            input_node for input_node in name_to_input_name[current_node_name]
+            if input_node not in visited
+        ]
+      elif (is_op_hint_unstack or
+            (do_generic_pack_unpack and node.op == "Unpack")):
+        unpack_nodes.add(node.name)
+        is_hint_created_stack &= is_op_hint_unstack
+      else:
+        matches_pattern = False
+        break
+      visited.add(node.name)
+
+    if matches_pattern and len(unpack_nodes) == 1:
+      pack_node = node_name
+
+      # Check to see if anyone depends on the intermediate identity or the
+      # Unstacked form
+      no_external_dependency = True
+      for other_n in in_graph_def.node:
+        if other_n.name in visited:
+          continue
+        for input_tensor in name_to_input_name[other_n.name]:
+          input_op = _tensor_name_base(input_tensor)
+          if input_op in visited and input_op != pack_node:
+            no_external_dependency = False
+      # Proceed with the substitution if the stack/unstack pair was created
+      # through hints, or that it was not, but nobody is consuming things
+      # between the stack and unstack.
+      if is_hint_created_stack or no_external_dependency:
+        end = unpack_nodes.pop()
+        end_input = name_to_node[end].input[0]
+        # All nodes that depend on the final stack need to be redone to use
+        for other_n in in_graph_def.node:
+          node_name = _tensor_name_base(other_n.name)
+          if node_name not in visited:
+            new_node = _copy.deepcopy(other_n)
+            new_node.input[:] = [
+                (end_input if stripped == pack_node else non_stripped)
+                for stripped, non_stripped in zip(name_to_input_name[node_name],
+                                                  new_node.input[:])
+            ]
+            out.node.extend([new_node])
+        return out, True
+  return in_graph_def, False
+
+
+def _remove_redundant_stack_unstack(graph_def):
+  curr = graph_def
+  del graph_def
+  changed_stuff = True
+  while changed_stuff:
+    curr, changed_stuff = _remove_one_redundant_stack_unstack(curr)
+  return curr
+
+
+def _get_correct_mapping(original_index, nodes):
+  # Special handle for the index is -1 case.
+  # If it is -1, return the last index.
+  if original_index == -1:
+    node_indices = nodes.keys()
+    node_indices = sorted(node_indices)
+    return node_indices[-1]
+  return original_index
+
+
+def _convert_op_hints_to_stubs_helper(
+    graph_def, write_callback=lambda sess, graph_def: None):
+  """Converts a graph_def to a new graph_def where all op hints are stubbed.
+
+  Args:
+    graph_def: A graph def that we should convert.
+    write_callback: A function pointer that can be used to write intermediate
+      steps of graph transformation (optional).
+
+  Returns:
+    A new stubbed graph_def.
+  """
+  hints = _find_all_hints_in_nodes(graph_def.node)
+
+  hints_q = []
+  for hint in hints.values():
+    hints_q.append((hint.level, hint.uuid))
+
+  hints_q.sort(key=lambda tup: tup[0])
+  for i in range(len(hints_q) - 1, -1, -1):
+    level, hint_uuid = hints_q[i]
+
+  curr_graph_def = graph_def
+  del graph_def  # prevent using graph_def again (common source of error)
+  for i in range(len(hints_q) - 1, -1, -1):
+    level, hint_uuid = hints_q[i]
+    if level >= 2:
+      children_hints, curr_graph_def, function_def_nodes = _find_children_hints(
+          hints[hint_uuid], curr_graph_def)
+      # pylint: disable=superfluous-parens
+      assert (len(children_hints) > 0)  #  pylint: disable=g-explicit-length-test
+      # pylint: enable=superfluous-parens
+
+      # Re-wire the children hints inputs/outputs, so latter child's inputs
+      # connect to previous child node's outputs.
+      children_inputs_mappings = hints[hint_uuid].children_inputs_mappings
+      for j, child_hint in enumerate(children_hints):
+        if j == 0:
+          for mapping in children_inputs_mappings["parent_first_child_input"]:
+            parent_input_index = _get_correct_mapping(
+                mapping["parent_ophint_input_index"], hints[hint_uuid].inputs)
+            child_input_index = _get_correct_mapping(
+                mapping["first_child_ophint_input_index"], child_hint.inputs)
+            child_hint.inputs[child_input_index] = hints[hint_uuid].inputs[
+                parent_input_index]
+        else:
+          for mapping in children_inputs_mappings[
+              "internal_children_input_output"]:
+            input_index = _get_correct_mapping(mapping["child_input_index"],
+                                               child_hint.inputs)
+            output_index = _get_correct_mapping(mapping["child_output_index"],
+                                                children_hints[j - 1].outputs)
+            child_hint.inputs[input_index] = children_hints[
+                j - 1].outputs[output_index]
+        if j == len(children_hints) - 1:
+          for mapping in children_inputs_mappings["parent_last_child_output"]:
+            parent_output_index = _get_correct_mapping(
+                mapping["parent_output_index"], hints[hint_uuid].outputs)
+            child_output_index = _get_correct_mapping(
+                mapping["child_output_index"], child_hint.outputs)
+            child_hint.outputs[child_output_index] = hints[hint_uuid].outputs[
+                parent_output_index]
+
+      for j, child_hint in enumerate(children_hints):
+        curr_graph_def = _convert_single_op_hint_to_stub(
+            child_hint, curr_graph_def, function_def_nodes,
+            j == len(children_hints) - 1)
+    else:
+      curr_graph_def = _convert_single_op_hint_to_stub(hints[hint_uuid],
+                                                       curr_graph_def)
+      write_callback(curr_graph_def, "initial")
+  # The stubbing process can create stacks/unstacks in the case of LSTMs
+  # remove them.
+  curr_graph_def = _remove_redundant_stack_unstack(curr_graph_def)
+  return curr_graph_def
+
+
+def find_all_hinted_output_nodes(session=None, graph_def=None):
+  """Find all Ophints output nodes in the graph.
+
+  This is used to get all the output nodes those are ophinted, it is important
+  for operation like convert_variables_to_constants keep all ophints structure.
+  Note: only one of session or graph_def should be used, not both.
+  Why this can be useful? Some TensorFlow ops (e.g. bidirectional rnn), can
+  generate multiple outputs for unfused subgraph. If not all output nodes are
+  consumed, graph optimization can potentially drop the unused nodes and cause
+  ophints in an invalid states (due to missing ophinted output nodes). So it's
+  important for us to find all those hinted output nodes and make sure they're
+  not discarded away.
+
+  Args:
+    session: A TensorFlow session that contains the graph to convert.
+    graph_def: A graph def that we should convert.
+
+  Returns:
+    A list of OpHints output nodes.
+  Raises:
+    ValueError: If both session and graph_def are provided.
+  """
+  if session is not None and graph_def is not None:
+    raise ValueError("Provide only one of session and graph_def.")
+  hinted_outputs_nodes = []
+  if session is not None:
+    hints = _find_all_hints_in_nodes(session.graph_def.node)
+  elif graph_def is not None:
+    hints = _find_all_hints_in_nodes(graph_def.node)
+  for hint in hints.values():
+    _, output_nodes = hint.flattened_inputs_and_outputs()
+    hinted_outputs_nodes.extend(output_nodes)
+  return hinted_outputs_nodes
+
+
+def is_ophint_converted(graph_def):
+  if graph_def is None:
+    raise ValueError("Must provide the graph_def.")
+  ophint_converted = False
+  for node in graph_def.node:
+    attr = node.attr
+    if OpHint.FUNCTION_INPUT_INDEX_ATTR in attr:
+      ophint_converted = True
+      break
+  return ophint_converted
+
+
+@_tf_export(v1=["lite.experimental.convert_op_hints_to_stubs"])
+@_deprecation.deprecated(
+    None,
+    "Please follow instructions under "
+    "https://www.tensorflow.org/lite/convert/operation_fusion for operation"
+    "fusion in tflite."
+)
+def convert_op_hints_to_stubs(session=None,
+                              graph_def=None,
+                              write_callback=lambda graph_def, comments: None):
+  """Converts a graphdef with LiteOp hints into stub operations.
+
+  This is used to prepare for toco conversion of complex intrinsic usages.
+  Note: only one of session or graph_def should be used, not both.
+
+  Args:
+    session: A TensorFlow session that contains the graph to convert.
+    graph_def: A graph def that we should convert.
+    write_callback: A function pointer that can be used to write intermediate
+      steps of graph transformation (optional).
+
+  Returns:
+    A new graphdef with all ops contained in OpHints being replaced by
+    a single op call with the right parameters.
+  Raises:
+    ValueError: If both session and graph_def are provided.
+  """
+
+  if session is not None and graph_def is not None:
+    raise ValueError("Provide only one of session and graph_def.")
+
+  if session is not None:
+    return _convert_op_hints_to_stubs_helper(session.graph_def, write_callback)
+  elif graph_def is not None:
+    return _convert_op_hints_to_stubs_helper(graph_def, write_callback)
+  else:
+    raise ValueError("Must specify session or graph_def as input.")
+
+
+_allowed_symbols = [
+    "OpHint",
+    "convert_op_hints_to_stubs",
+    "convert_op_hints_to_stubs_new",
+    "find_all_hinted_output_nodes",
+    "is_ophint_converted",
+]
+remove_undocumented(__name__, _allowed_symbols)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/optimize/_pywrap_tensorflow_lite_calibration_wrapper.pyi

@@ -0,0 +1,40 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from typing import Callable
+
+from typing import overload
+
+class CalibrationWrapper:
+    def __init__(self, arg0: object, arg1: list[str], arg2: list[Callable[[int],None]]) -> None: ...
+    def Calibrate(self) -> object: ...
+    @overload
+    def FeedTensor(self, arg0: object, arg1: str) -> object: ...
+    @overload
+    def FeedTensor(self, arg0: object) -> object: ...
+    @overload
+    def Prepare(self, arg0: object, arg1: str) -> object: ...
+    @overload
+    def Prepare(self, arg0: object) -> object: ...
+    @overload
+    def Prepare(self, arg0: str) -> object: ...
+    @overload
+    def Prepare(self) -> object: ...
+    @overload
+    def QuantizeModel(self, arg0: int, arg1: int, arg2: bool, arg3: int, arg4: int, arg5: bool) -> object: ...
+    @overload
+    def QuantizeModel(self, arg0: int, arg1: int, arg2: bool, arg3: str) -> object: ...
+
+def AddIntermediateTensors(arg0: object) -> object: ...

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/optimize/calibrator.py

@@ -0,0 +1,255 @@
+# 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.
+# ==============================================================================
+"""Python wrapper for post training quantization with calibration."""
+import numpy as np
+
+from tensorflow.lite.python.convert_phase import Component
+from tensorflow.lite.python.convert_phase import convert_phase
+from tensorflow.lite.python.convert_phase import SubComponent
+from tensorflow.lite.python.interpreter import Interpreter
+from tensorflow.python.framework import dtypes
+from tensorflow.python.util.lazy_loader import LazyLoader
+
+# Lazy load since some of the performance benchmark skylark rules
+# break dependencies. Must use double quotes to match code internal rewrite
+# rule.
+_calibration_wrapper = LazyLoader(
+    "_calibration_wrapper",
+    globals(),
+    (
+        "tensorflow.lite.python.optimize."
+        "_pywrap_tensorflow_lite_calibration_wrapper"
+    ),
+)
+
+
+def add_intermediate_tensors(model_content):
+  """Adds intermediate tensors to fused op if needed."""
+  return _calibration_wrapper.AddIntermediateTensors(model_content)
+
+
+class Calibrator:
+  """Calibrates a floating point model and then quantizes it.
+
+  This is an internal class, not a public interface.
+  """
+
+  def __init__(
+      self,
+      model_content,
+      custom_op_registerers_by_name=None,
+      custom_op_registerers_by_func=None,
+  ):
+    """Constructor.
+
+    Args:
+      model_content: Content of a TF-Lite Flatbuffer file.
+      custom_op_registerers_by_name: List of str (symbol names) that take a
+        pointer to a MutableOpResolver and register custom ops.
+      custom_op_registerers_by_func: List of functions that take a pointer to a
+        MutableOpResolver and register custom ops.
+
+    Raises:
+      ValueError: If the calibrator was unable to open the model.
+    """
+    if not model_content:
+      raise ValueError("`model_content` must be specified.")
+    if custom_op_registerers_by_name is None:
+      custom_op_registerers_by_name = []
+    if custom_op_registerers_by_func is None:
+      custom_op_registerers_by_func = []
+    try:
+      self._calibrator = _calibration_wrapper.CalibrationWrapper(
+          model_content,
+          custom_op_registerers_by_name,
+          custom_op_registerers_by_func,
+      )
+      self._model_content = model_content
+    except Exception as e:
+      raise ValueError("Failed to parse the model: %s." % e)
+    if not self._calibrator:
+      raise ValueError("Failed to parse the model.")
+    self._interpreter = None
+
+  def _create_input_array_from_dict(self, signature_key, inputs):
+    input_array = []
+    signature_runner = self._interpreter.get_signature_runner(signature_key)
+    input_details = sorted(
+        signature_runner.get_input_details().items(),
+        key=lambda item: item[1]["index"],
+    )
+    for input_name, _ in input_details:
+      input_array.append(inputs[input_name])
+    return input_array
+
+  def _feed_tensors(self, dataset_gen, resize_input):
+    """Feed tensors to the calibrator."""
+    initialized = {}
+
+    for sample in dataset_gen():
+      if isinstance(sample, tuple):
+        if not isinstance(sample[1], dict):
+          raise ValueError(
+              "You need to provide either a dictionary with input "
+              "names and values in the second argument in the "
+              "tuple"
+          )
+        # Convert signature based inputs to the tensor index based data.
+        if self._interpreter is None:
+          self._interpreter = Interpreter(model_content=self._model_content)
+        signature_key = sample[0]
+        input_array = self._create_input_array_from_dict(
+            signature_key, sample[1]
+        )
+      elif isinstance(sample, dict):
+        # Convert signature based inputs to the tensor index based data.
+        if self._interpreter is None:
+          self._interpreter = Interpreter(model_content=self._model_content)
+        signature_key = None
+        input_array = self._create_input_array_from_dict(None, sample)
+      elif isinstance(sample, list):
+        signature_key = None
+        input_array = sample
+      else:
+        raise ValueError(
+            "You need to provide either a dictionary with input "
+            "names and values, a tuple with signature key and a "
+            "dictionary with input names and values, or an array "
+            "with input values in the order of input tensors of "
+            "the graph in the representative_dataset function. "
+            "Unsupported value from dataset: {}.".format(sample)
+        )
+
+      if signature_key not in initialized:
+        initialized[signature_key] = True
+        if resize_input:
+          if signature_key is not None:
+            self._calibrator.Prepare(
+                [list(s.shape) for s in input_array], signature_key
+            )
+          else:
+            self._calibrator.Prepare([list(s.shape) for s in input_array])
+        else:
+          if signature_key is not None:
+            self._calibrator.Prepare(signature_key)
+          else:
+            self._calibrator.Prepare()
+      if signature_key is not None:
+        self._calibrator.FeedTensor(input_array, signature_key)
+      else:
+        self._calibrator.FeedTensor(input_array)
+
+  @convert_phase(
+      Component.OPTIMIZE_TFLITE_MODEL,
+      SubComponent.QUANTIZE_USING_DEPRECATED_QUANTIZER,
+  )
+  def calibrate_and_quantize(
+      self,
+      dataset_gen,
+      input_type,
+      output_type,
+      allow_float,
+      activations_type=dtypes.int8,
+      bias_type=dtypes.int32,
+      resize_input=True,
+      disable_per_channel=False,
+  ):
+    """Calibrates the model with specified generator and then quantizes it.
+
+    The input shapes of the calibrator are resized with the calibration data if
+    `resize_input` is set.
+
+    Returns:
+      A quantized model.
+
+    Args:
+      dataset_gen: A generator that generates calibration samples.
+      input_type: A tf.dtype representing the desired real-value input type.
+      output_type: A tf.dtype representing the desired real-value output type.
+      allow_float: A boolean. False if the resulting model cannot perform float
+        computation, useful when targeting an integer-only backend. If False, an
+        error will be thrown if an operation cannot be quantized, otherwise the
+        model will fallback to float ops.
+      activations_type: A tf.dtype representing the desired type for
+        activations.
+      bias_type: A tf.dtype representing the desired type for bias.
+      resize_input: A boolean. True if the shape of the sample data is different
+        from the input.
+      disable_per_channel: A boolean. True if disabling per-channel
+        quantization.
+    """
+    self._feed_tensors(dataset_gen, resize_input)
+    return self._calibrator.QuantizeModel(
+        np.dtype(input_type.as_numpy_dtype()).num,
+        np.dtype(output_type.as_numpy_dtype()).num,
+        allow_float,
+        np.dtype(activations_type.as_numpy_dtype()).num,
+        np.dtype(bias_type.as_numpy_dtype()).num,
+        disable_per_channel,
+    )
+
+  @convert_phase(
+      Component.OPTIMIZE_TFLITE_MODEL,
+      SubComponent.QUANTIZE_USING_DEPRECATED_QUANTIZER,
+  )
+  def calibrate_and_quantize_single(
+      self,
+      dataset_gen,
+      input_type,
+      output_type,
+      allow_float,
+      op_output_name,
+      resize_input=True,
+  ):
+    """Calibrates the model with specified generator and then quantizes it.
+
+    Only the single op with output op_output_name will be quantized.
+    The input shapes of the calibrator are resized with the calibration data.
+
+    Returns:
+      A quantized model.
+
+    Args:
+      dataset_gen: A generator that generates calibration samples.
+      input_type: A tf.dtype representing the desired real-value input type.
+      output_type: A tf.dtype representing the desired real-value output type.
+      allow_float: A boolean. False if the resulting model cannot perform float
+        computation, useful when targeting an integer-only backend. If False, an
+        error will be thrown if an operation cannot be quantized, otherwise the
+        model will fallback to float ops.
+      op_output_name: A string, only this op will be quantized.
+      resize_input: A boolean. True if the shape of the sample data is different
+        from the input.
+    """
+    self._feed_tensors(dataset_gen, resize_input)
+    return self._calibrator.QuantizeModel(
+        np.dtype(input_type.as_numpy_dtype()).num,
+        np.dtype(output_type.as_numpy_dtype()).num,
+        allow_float,
+        op_output_name,
+    )
+
+  @convert_phase(Component.OPTIMIZE_TFLITE_MODEL, SubComponent.CALIBRATE)
+  def calibrate(self, dataset_gen):
+    """Calibrates the model with specified generator.
+
+    Returns:
+      A model with min and max calibration stats.
+
+    Args:
+      dataset_gen: A generator that generates calibration samples.
+    """
+    self._feed_tensors(dataset_gen, resize_input=True)
+    return self._calibrator.Calibrate()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/schema_util.py

@@ -0,0 +1,45 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Schema utilities to get builtin code from operator code."""
+
+from tensorflow.python.util import all_util
+
+
+def get_builtin_code_from_operator_code(opcode):
+  """Return the builtin code of the given operator code.
+
+  The following method is introduced to resolve op builtin code shortage
+  problem. The new builtin operator will be assigned to the extended builtin
+  code field in the flatbuffer schema. Those methods helps to hide builtin code
+  details.
+
+  Args:
+    opcode: Operator code.
+
+  Returns:
+    The builtin code of the given operator code.
+  """
+  # Access BuiltinCode() method first if available.
+  if hasattr(opcode, 'BuiltinCode') and callable(opcode.BuiltinCode):
+    return max(opcode.BuiltinCode(), opcode.DeprecatedBuiltinCode())
+
+  return max(opcode.builtinCode, opcode.deprecatedBuiltinCode)
+
+
+_allowed_symbols = [
+    'get_builtin_code_from_operator_code',
+]
+
+all_util.remove_undocumented(__name__, _allowed_symbols)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/tflite_convert.py

@@ -0,0 +1,694 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python command line interface for converting TF models to TFLite models."""
+
+import argparse
+import os
+import sys
+import warnings
+
+from absl import app
+import tensorflow as tf  # pylint: disable=unused-import
+
+from tensorflow.lite.python import lite
+from tensorflow.lite.python.convert import register_custom_opdefs
+from tensorflow.lite.toco import toco_flags_pb2 as _toco_flags_pb2
+from tensorflow.lite.toco.logging import gen_html
+from tensorflow.python import tf2
+from tensorflow.python.framework import dtypes
+from tensorflow.python.platform import gfile
+from tensorflow.python.util import keras_deps
+
+# Needed to enable TF2 by default.
+
+
+def _parse_array(values, type_fn=str):
+  if values is not None:
+    return [type_fn(val) for val in values.split(",") if val]
+  return None
+
+
+def _parse_set(values):
+  if values is not None:
+    return set([item for item in values.split(",") if item])
+  return None
+
+
+def _parse_inference_type(value, flag):
+  """Converts the inference type to the value of the constant.
+
+  Args:
+    value: str representing the inference type.
+    flag: str representing the flag name.
+
+  Returns:
+    tf.dtype.
+
+  Raises:
+    ValueError: Unsupported value.
+  """
+  if value == "FLOAT":
+    return dtypes.float32
+  if value == "INT8":
+    return dtypes.int8
+  if value == "UINT8" or value == "QUANTIZED_UINT8":
+    return dtypes.uint8
+  raise ValueError(
+      "Unsupported value for `{}` flag. Expected FLOAT, INT8, UINT8, or "
+      "QUANTIZED_UINT8 instead got {}.".format(flag, value))
+
+
+class _ParseBooleanFlag(argparse.Action):
+  """Helper class to parse boolean flag that optionally accepts truth value."""
+
+  def __init__(self, option_strings, dest, nargs=None, **kwargs):
+    if nargs != "?":
+      # This should never happen. This class is only used once below with
+      # nargs="?".
+      raise ValueError(
+          "This parser only supports nargs='?' (0 or 1 additional arguments)")
+    super(_ParseBooleanFlag, self).__init__(
+        option_strings, dest, nargs=nargs, **kwargs)
+
+  def __call__(self, parser, namespace, values, option_string=None):
+    if values is None:
+      # Handling `--boolean_flag`.
+      # Without additional arguments, it implies true.
+      flag_value = True
+    elif values.lower() == "true":
+      # Handling `--boolean_flag=true`.
+      # (Case insensitive after the equal sign)
+      flag_value = True
+    elif values.lower() == "false":
+      # Handling `--boolean_flag=false`.
+      # (Case insensitive after the equal sign)
+      flag_value = False
+    else:
+      raise ValueError("Invalid argument to --{}. Must use flag alone,"
+                       " or specify true/false.".format(self.dest))
+    setattr(namespace, self.dest, flag_value)
+
+
+def _get_tflite_converter(flags):
+  """Makes a TFLiteConverter object based on the flags provided.
+
+  Args:
+    flags: argparse.Namespace object containing TFLite flags.
+
+  Returns:
+    TFLiteConverter object.
+
+  Raises:
+    ValueError: Invalid flags.
+  """
+  # Parse input and output arrays.
+  input_arrays = _parse_array(flags.input_arrays)
+  input_shapes = None
+  if flags.input_shapes:
+    input_shapes_list = [
+        _parse_array(shape, type_fn=int)
+        for shape in flags.input_shapes.split(":")
+    ]
+    input_shapes = dict(list(zip(input_arrays, input_shapes_list)))
+  output_arrays = _parse_array(flags.output_arrays)
+
+  converter_kwargs = {
+      "input_arrays": input_arrays,
+      "input_shapes": input_shapes,
+      "output_arrays": output_arrays
+  }
+
+  # Create TFLiteConverter.
+  if flags.graph_def_file:
+    converter_fn = lite.TFLiteConverter.from_frozen_graph
+    converter_kwargs["graph_def_file"] = flags.graph_def_file
+  elif flags.saved_model_dir:
+    converter_fn = lite.TFLiteConverter.from_saved_model
+    converter_kwargs["saved_model_dir"] = flags.saved_model_dir
+    converter_kwargs["tag_set"] = _parse_set(flags.saved_model_tag_set)
+    converter_kwargs["signature_key"] = flags.saved_model_signature_key
+  elif flags.keras_model_file:
+    converter_fn = lite.TFLiteConverter.from_keras_model_file
+    converter_kwargs["model_file"] = flags.keras_model_file
+  else:
+    raise ValueError("--graph_def_file, --saved_model_dir, or "
+                     "--keras_model_file must be specified.")
+
+  return converter_fn(**converter_kwargs)
+
+
+def _convert_tf1_model(flags):
+  """Calls function to convert the TensorFlow 1.X model into a TFLite model.
+
+  Args:
+    flags: argparse.Namespace object.
+
+  Raises:
+    ValueError: Invalid flags.
+  """
+  # Register custom opdefs before converter object creation.
+  if flags.custom_opdefs:
+    register_custom_opdefs(_parse_array(flags.custom_opdefs))
+
+  # Create converter.
+  converter = _get_tflite_converter(flags)
+  if flags.inference_type:
+    converter.inference_type = _parse_inference_type(flags.inference_type,
+                                                     "inference_type")
+  if flags.inference_input_type:
+    converter.inference_input_type = _parse_inference_type(
+        flags.inference_input_type, "inference_input_type")
+  if flags.output_format:
+    converter.output_format = _toco_flags_pb2.FileFormat.Value(
+        flags.output_format)
+
+  if flags.mean_values and flags.std_dev_values:
+    input_arrays = converter.get_input_arrays()
+    std_dev_values = _parse_array(flags.std_dev_values, type_fn=float)
+
+    # In quantized inference, mean_value has to be integer so that the real
+    # value 0.0 is exactly representable.
+    if converter.inference_type == dtypes.float32:
+      mean_values = _parse_array(flags.mean_values, type_fn=float)
+    else:
+      mean_values = _parse_array(flags.mean_values, type_fn=int)
+    quant_stats = list(zip(mean_values, std_dev_values))
+    if ((not flags.input_arrays and len(input_arrays) > 1) or
+        (len(input_arrays) != len(quant_stats))):
+      raise ValueError("Mismatching --input_arrays, --std_dev_values, and "
+                       "--mean_values. The flags must have the same number of "
+                       "items. The current input arrays are '{0}'. "
+                       "--input_arrays must be present when specifying "
+                       "--std_dev_values and --mean_values with multiple input "
+                       "tensors in order to map between names and "
+                       "values.".format(",".join(input_arrays)))
+    converter.quantized_input_stats = dict(list(zip(input_arrays, quant_stats)))
+  if (flags.default_ranges_min is not None) and (flags.default_ranges_max is
+                                                 not None):
+    converter.default_ranges_stats = (flags.default_ranges_min,
+                                      flags.default_ranges_max)
+
+  if flags.drop_control_dependency:
+    converter.drop_control_dependency = flags.drop_control_dependency
+  if flags.reorder_across_fake_quant:
+    converter.reorder_across_fake_quant = flags.reorder_across_fake_quant
+  if flags.change_concat_input_ranges:
+    converter.change_concat_input_ranges = (
+        flags.change_concat_input_ranges == "TRUE")
+
+  if flags.allow_custom_ops:
+    converter.allow_custom_ops = flags.allow_custom_ops
+
+  if flags.target_ops:
+    ops_set_options = lite.OpsSet.get_options()
+    converter.target_spec.supported_ops = set()
+    for option in flags.target_ops.split(","):
+      if option not in ops_set_options:
+        raise ValueError("Invalid value for --target_ops. Options: "
+                         "{0}".format(",".join(ops_set_options)))
+      converter.target_spec.supported_ops.add(lite.OpsSet(option))
+
+  if flags.experimental_select_user_tf_ops:
+    if lite.OpsSet.SELECT_TF_OPS not in converter.target_spec.supported_ops:
+      raise ValueError("--experimental_select_user_tf_ops can only be set if "
+                       "--target_ops contains SELECT_TF_OPS.")
+    user_op_set = set()
+    for op_name in flags.experimental_select_user_tf_ops.split(","):
+      user_op_set.add(op_name)
+    converter.target_spec.experimental_select_user_tf_ops = list(user_op_set)
+
+  if flags.post_training_quantize:
+    converter.optimizations = [lite.Optimize.DEFAULT]
+    if converter.inference_type != dtypes.float32:
+      print("--post_training_quantize quantizes a graph of inference_type "
+            "FLOAT. Overriding inference_type to FLOAT.")
+      converter.inference_type = dtypes.float32
+
+  if flags.quantize_to_float16:
+    converter.target_spec.supported_types = [dtypes.float16]
+    if not flags.post_training_quantize:
+      print("--quantize_to_float16 will only take effect with the "
+            "--post_training_quantize flag enabled.")
+
+  if flags.dump_graphviz_dir:
+    converter.dump_graphviz_dir = flags.dump_graphviz_dir
+  if flags.dump_graphviz_video:
+    converter.dump_graphviz_vode = flags.dump_graphviz_video
+  if flags.conversion_summary_dir:
+    converter.conversion_summary_dir = flags.conversion_summary_dir
+
+  converter.experimental_new_converter = flags.experimental_new_converter
+
+  if flags.experimental_new_quantizer is not None:
+    converter.experimental_new_quantizer = flags.experimental_new_quantizer
+
+  # Convert model.
+  output_data = converter.convert()
+  with gfile.GFile(flags.output_file, "wb") as f:
+    f.write(output_data)
+
+
+def _convert_tf2_model(flags):
+  """Calls function to convert the TensorFlow 2.0 model into a TFLite model.
+
+  Args:
+    flags: argparse.Namespace object.
+
+  Raises:
+    ValueError: Unsupported file format.
+  """
+  # Load the model.
+  if flags.saved_model_dir:
+    converter = lite.TFLiteConverterV2.from_saved_model(
+        flags.saved_model_dir,
+        signature_keys=_parse_array(flags.saved_model_signature_key),
+        tags=_parse_set(flags.saved_model_tag_set))
+  elif flags.keras_model_file:
+    model = keras_deps.get_load_model_function()(flags.keras_model_file)
+    converter = lite.TFLiteConverterV2.from_keras_model(model)
+
+  converter.experimental_new_converter = flags.experimental_new_converter
+
+  if flags.experimental_new_quantizer is not None:
+    converter.experimental_new_quantizer = flags.experimental_new_quantizer
+
+  # Convert the model.
+  tflite_model = converter.convert()
+  with gfile.GFile(flags.output_file, "wb") as f:
+    f.write(tflite_model)
+
+
+def _check_tf1_flags(flags, unparsed):
+  """Checks the parsed and unparsed flags to ensure they are valid in 1.X.
+
+  Raises an error if previously support unparsed flags are found. Raises an
+  error for parsed flags that don't meet the required conditions.
+
+  Args:
+    flags: argparse.Namespace object containing TFLite flags.
+    unparsed: List of unparsed flags.
+
+  Raises:
+    ValueError: Invalid flags.
+  """
+
+  # Check unparsed flags for common mistakes based on previous TOCO.
+  def _get_message_unparsed(flag, orig_flag, new_flag):
+    if flag.startswith(orig_flag):
+      return "\n  Use {0} instead of {1}".format(new_flag, orig_flag)
+    return ""
+
+  if unparsed:
+    output = ""
+    for flag in unparsed:
+      output += _get_message_unparsed(flag, "--input_file", "--graph_def_file")
+      output += _get_message_unparsed(flag, "--savedmodel_directory",
+                                      "--saved_model_dir")
+      output += _get_message_unparsed(flag, "--std_value", "--std_dev_values")
+      output += _get_message_unparsed(flag, "--batch_size", "--input_shapes")
+      output += _get_message_unparsed(flag, "--dump_graphviz",
+                                      "--dump_graphviz_dir")
+    if output:
+      raise ValueError(output)
+
+  # Check that flags are valid.
+  if flags.graph_def_file and (not flags.input_arrays or
+                               not flags.output_arrays):
+    raise ValueError("--input_arrays and --output_arrays are required with "
+                     "--graph_def_file")
+
+  if flags.input_shapes:
+    if not flags.input_arrays:
+      raise ValueError("--input_shapes must be used with --input_arrays")
+    if flags.input_shapes.count(":") != flags.input_arrays.count(","):
+      raise ValueError("--input_shapes and --input_arrays must have the same "
+                       "number of items")
+
+  if flags.std_dev_values or flags.mean_values:
+    if bool(flags.std_dev_values) != bool(flags.mean_values):
+      raise ValueError("--std_dev_values and --mean_values must be used "
+                       "together")
+    if flags.std_dev_values.count(",") != flags.mean_values.count(","):
+      raise ValueError("--std_dev_values, --mean_values must have the same "
+                       "number of items")
+
+  if (flags.default_ranges_min is None) != (flags.default_ranges_max is None):
+    raise ValueError("--default_ranges_min and --default_ranges_max must be "
+                     "used together")
+
+  if flags.dump_graphviz_video and not flags.dump_graphviz_dir:
+    raise ValueError("--dump_graphviz_video must be used with "
+                     "--dump_graphviz_dir")
+
+  if flags.custom_opdefs and not flags.experimental_new_converter:
+    raise ValueError("--custom_opdefs must be used with "
+                     "--experimental_new_converter")
+  if flags.custom_opdefs and not flags.allow_custom_ops:
+    raise ValueError("--custom_opdefs must be used with --allow_custom_ops")
+  if (flags.experimental_select_user_tf_ops and
+      not flags.experimental_new_converter):
+    raise ValueError("--experimental_select_user_tf_ops must be used with "
+                     "--experimental_new_converter")
+
+
+def _check_tf2_flags(flags):
+  """Checks the parsed and unparsed flags to ensure they are valid in 2.X.
+
+  Args:
+    flags: argparse.Namespace object containing TFLite flags.
+
+  Raises:
+    ValueError: Invalid flags.
+  """
+  if not flags.keras_model_file and not flags.saved_model_dir:
+    raise ValueError("one of the arguments --saved_model_dir "
+                     "--keras_model_file is required")
+
+
+def _get_tf1_flags(parser):
+  """Returns ArgumentParser for tflite_convert for TensorFlow 1.X.
+
+  Args:
+    parser: ArgumentParser
+  """
+  # Input file flags.
+  input_file_group = parser.add_mutually_exclusive_group(required=True)
+  input_file_group.add_argument(
+      "--graph_def_file",
+      type=str,
+      help="Full filepath of file containing frozen TensorFlow GraphDef.")
+  input_file_group.add_argument(
+      "--saved_model_dir",
+      type=str,
+      help="Full filepath of directory containing the SavedModel.")
+  input_file_group.add_argument(
+      "--keras_model_file",
+      type=str,
+      help="Full filepath of HDF5 file containing tf.Keras model.")
+
+  # Model format flags.
+  parser.add_argument(
+      "--output_format",
+      type=str.upper,
+      choices=["TFLITE", "GRAPHVIZ_DOT"],
+      help="Output file format.")
+  parser.add_argument(
+      "--inference_type",
+      type=str.upper,
+      default="FLOAT",
+      help=("Target data type of real-number arrays in the output file. "
+            "Must be either FLOAT, INT8 or UINT8."))
+  parser.add_argument(
+      "--inference_input_type",
+      type=str.upper,
+      help=("Target data type of real-number input arrays. Allows for a "
+            "different type for input arrays in the case of quantization. "
+            "Must be either FLOAT, INT8 or UINT8."))
+
+  # Input and output arrays flags.
+  parser.add_argument(
+      "--input_arrays",
+      type=str,
+      help="Names of the input arrays, comma-separated.")
+  parser.add_argument(
+      "--input_shapes",
+      type=str,
+      help="Shapes corresponding to --input_arrays, colon-separated.")
+  parser.add_argument(
+      "--output_arrays",
+      type=str,
+      help="Names of the output arrays, comma-separated.")
+
+  # SavedModel related flags.
+  parser.add_argument(
+      "--saved_model_tag_set",
+      type=str,
+      help=("Comma-separated set of tags identifying the MetaGraphDef within "
+            "the SavedModel to analyze. All tags must be present. In order to "
+            "pass in an empty tag set, pass in \"\". (default \"serve\")"))
+  parser.add_argument(
+      "--saved_model_signature_key",
+      type=str,
+      help=("Key identifying the SignatureDef containing inputs and outputs. "
+            "(default DEFAULT_SERVING_SIGNATURE_DEF_KEY)"))
+
+  # Quantization flags.
+  parser.add_argument(
+      "--std_dev_values",
+      type=str,
+      help=("Standard deviation of training data for each input tensor, "
+            "comma-separated floats. Used for quantized input tensors. "
+            "(default None)"))
+  parser.add_argument(
+      "--mean_values",
+      type=str,
+      help=("Mean of training data for each input tensor, comma-separated "
+            "floats. Used for quantized input tensors. (default None)"))
+  parser.add_argument(
+      "--default_ranges_min",
+      type=float,
+      help=("Default value for min bound of min/max range values used for all "
+            "arrays without a specified range, Intended for experimenting with "
+            "quantization via \"dummy quantization\". (default None)"))
+  parser.add_argument(
+      "--default_ranges_max",
+      type=float,
+      help=("Default value for max bound of min/max range values used for all "
+            "arrays without a specified range, Intended for experimenting with "
+            "quantization via \"dummy quantization\". (default None)"))
+  # quantize_weights is DEPRECATED.
+  parser.add_argument(
+      "--quantize_weights",
+      dest="post_training_quantize",
+      action="store_true",
+      help=argparse.SUPPRESS)
+  parser.add_argument(
+      "--post_training_quantize",
+      dest="post_training_quantize",
+      action="store_true",
+      help=(
+          "Boolean indicating whether to quantize the weights of the "
+          "converted float model. Model size will be reduced and there will "
+          "be latency improvements (at the cost of accuracy). (default False)"))
+  parser.add_argument(
+      "--quantize_to_float16",
+      dest="quantize_to_float16",
+      action="store_true",
+      help=("Boolean indicating whether to quantize weights to fp16 instead of "
+            "the default int8 when post-training quantization "
+            "(--post_training_quantize) is enabled. (default False)"))
+  # Graph manipulation flags.
+  parser.add_argument(
+      "--drop_control_dependency",
+      action="store_true",
+      help=("Boolean indicating whether to drop control dependencies silently. "
+            "This is due to TensorFlow not supporting control dependencies. "
+            "(default True)"))
+  parser.add_argument(
+      "--reorder_across_fake_quant",
+      action="store_true",
+      help=("Boolean indicating whether to reorder FakeQuant nodes in "
+            "unexpected locations. Used when the location of the FakeQuant "
+            "nodes is preventing graph transformations necessary to convert "
+            "the graph. Results in a graph that differs from the quantized "
+            "training graph, potentially causing differing arithmetic "
+            "behavior. (default False)"))
+  # Usage for this flag is --change_concat_input_ranges=true or
+  # --change_concat_input_ranges=false in order to make it clear what the flag
+  # is set to. This keeps the usage consistent with other usages of the flag
+  # where the default is different. The default value here is False.
+  parser.add_argument(
+      "--change_concat_input_ranges",
+      type=str.upper,
+      choices=["TRUE", "FALSE"],
+      help=("Boolean to change behavior of min/max ranges for inputs and "
+            "outputs of the concat operator for quantized models. Changes the "
+            "ranges of concat operator overlap when true. (default False)"))
+
+  # Permitted ops flags.
+  parser.add_argument(
+      "--allow_custom_ops",
+      action=_ParseBooleanFlag,
+      nargs="?",
+      help=("Boolean indicating whether to allow custom operations. When false "
+            "any unknown operation is an error. When true, custom ops are "
+            "created for any op that is unknown. The developer will need to "
+            "provide these to the TensorFlow Lite runtime with a custom "
+            "resolver. (default False)"))
+  parser.add_argument(
+      "--custom_opdefs",
+      type=str,
+      help=("String representing a list of custom ops OpDefs delineated with "
+            "commas that are included in the GraphDef. Required when using "
+            "custom operations with --experimental_new_converter."))
+  parser.add_argument(
+      "--target_ops",
+      type=str,
+      help=("Experimental flag, subject to change. Set of OpsSet options "
+            "indicating which converter to use. Options: {0}. One or more "
+            "option may be specified. (default set([OpsSet.TFLITE_BUILTINS]))"
+            "".format(",".join(lite.OpsSet.get_options()))))
+  parser.add_argument(
+      "--experimental_select_user_tf_ops",
+      type=str,
+      help=("Experimental flag, subject to change. Comma separated list of "
+            "user's defined TensorFlow operators required in the runtime."))
+
+  # Logging flags.
+  parser.add_argument(
+      "--dump_graphviz_dir",
+      type=str,
+      help=("Full filepath of folder to dump the graphs at various stages of "
+            "processing GraphViz .dot files. Preferred over --output_format="
+            "GRAPHVIZ_DOT in order to keep the requirements of the output "
+            "file."))
+  parser.add_argument(
+      "--dump_graphviz_video",
+      action="store_true",
+      help=("Boolean indicating whether to dump the graph after every graph "
+            "transformation"))
+  parser.add_argument(
+      "--conversion_summary_dir",
+      type=str,
+      help=("Full filepath to store the conversion logs, which includes "
+            "graphviz of the model before/after the conversion, an HTML report "
+            "and the conversion proto buffers. This will only be generated "
+            "when passing --experimental_new_converter"))
+
+
+def _get_tf2_flags(parser):
+  """Returns ArgumentParser for tflite_convert for TensorFlow 2.0.
+
+  Args:
+    parser: ArgumentParser
+  """
+  # Input file flags.
+  input_file_group = parser.add_mutually_exclusive_group()
+  input_file_group.add_argument(
+      "--saved_model_dir",
+      type=str,
+      help="Full path of the directory containing the SavedModel.")
+  input_file_group.add_argument(
+      "--keras_model_file",
+      type=str,
+      help="Full filepath of HDF5 file containing tf.Keras model.")
+  # SavedModel related flags.
+  parser.add_argument(
+      "--saved_model_tag_set",
+      type=str,
+      help=("Comma-separated set of tags identifying the MetaGraphDef within "
+            "the SavedModel to analyze. All tags must be present. In order to "
+            "pass in an empty tag set, pass in \"\". (default \"serve\")"))
+  parser.add_argument(
+      "--saved_model_signature_key",
+      type=str,
+      help=("Key identifying the SignatureDef containing inputs and outputs. "
+            "(default DEFAULT_SERVING_SIGNATURE_DEF_KEY)"))
+
+  # Enables 1.X converter in 2.X.
+  parser.add_argument(
+      "--enable_v1_converter",
+      action="store_true",
+      help=("Enables the TensorFlow V1 converter in 2.0"))
+
+
+def _get_parser(use_v2_converter):
+  """Returns an ArgumentParser for tflite_convert.
+
+  Args:
+    use_v2_converter: Indicates which converter to return.
+  Return: ArgumentParser.
+  """
+  parser = argparse.ArgumentParser(
+      description=("Command line tool to run TensorFlow Lite Converter."))
+
+  # Output file flag.
+  parser.add_argument(
+      "--output_file",
+      type=str,
+      help="Full filepath of the output file.",
+      required=True)
+
+  if use_v2_converter:
+    _get_tf2_flags(parser)
+  else:
+    _get_tf1_flags(parser)
+
+  parser.add_argument(
+      "--experimental_new_converter",
+      action=_ParseBooleanFlag,
+      nargs="?",
+      default=True,
+      help=("Experimental flag, subject to change. Enables MLIR-based "
+            "conversion instead of TOCO conversion. (default True)"))
+
+  parser.add_argument(
+      "--experimental_new_quantizer",
+      action=_ParseBooleanFlag,
+      nargs="?",
+      help=("Experimental flag, subject to change. Enables MLIR-based "
+            "quantizer instead of flatbuffer conversion. (default True)"))
+  return parser
+
+
+def run_main(_):
+  """Main in tflite_convert.py."""
+  use_v2_converter = tf2.enabled()
+  parser = _get_parser(use_v2_converter)
+  tflite_flags, unparsed = parser.parse_known_args(args=sys.argv[1:])
+
+  # If the user is running TensorFlow 2.X but has passed in enable_v1_converter
+  # then parse the flags again with the 1.X converter flags.
+  if tf2.enabled() and tflite_flags.enable_v1_converter:
+    use_v2_converter = False
+    parser = _get_parser(use_v2_converter)
+    tflite_flags, unparsed = parser.parse_known_args(args=sys.argv[1:])
+
+  # Checks if the flags are valid.
+  try:
+    if use_v2_converter:
+      _check_tf2_flags(tflite_flags)
+    else:
+      _check_tf1_flags(tflite_flags, unparsed)
+  except ValueError as e:
+    parser.print_usage()
+    file_name = os.path.basename(sys.argv[0])
+    sys.stderr.write("{0}: error: {1}\n".format(file_name, str(e)))
+    sys.exit(1)
+
+  # Convert the model according to the user provided flag.
+  if use_v2_converter:
+    _convert_tf2_model(tflite_flags)
+  else:
+    try:
+      _convert_tf1_model(tflite_flags)
+    finally:
+      if tflite_flags.conversion_summary_dir:
+        if tflite_flags.experimental_new_converter:
+          gen_html.gen_conversion_log_html(tflite_flags.conversion_summary_dir,
+                                           tflite_flags.post_training_quantize,
+                                           tflite_flags.output_file)
+        else:
+          warnings.warn(
+              "Conversion summary will only be generated when enabling"
+              " the new converter via --experimental_new_converter. ")
+
+
+def main():
+  app.run(main=run_main, argv=sys.argv[:1])
+
+
+if __name__ == "__main__":
+  main()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/tflite_keras_util.py

@@ -0,0 +1,194 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Keras functions required by TensorFlow Lite.
+
+The functions defined in this library have been copied over from Keras in order
+to remove the dependency from TensorFlow Lite to Keras. The functions which
+could not be copied over are accessed using the dependency inversion principle.
+(for details, refer to tensorflow/python/util/keras_deps.py).
+"""
+
+import copy
+
+from tensorflow.python.eager import def_function
+from tensorflow.python.util import keras_deps
+from tensorflow.python.util import nest
+from tensorflow.python.util.compat import collections_abc
+
+
+def _enforce_names_consistency(specs):
+  """Enforces that either all specs have names or none do."""
+
+  def _has_name(spec):
+    return hasattr(spec, 'name') and spec.name is not None
+
+  def _clear_name(spec):
+    spec = copy.deepcopy(spec)
+    if hasattr(spec, 'name'):
+      spec._name = None  # pylint:disable=protected-access
+    return spec
+
+  flat_specs = nest.flatten(specs)
+  name_inconsistency = (
+      any(_has_name(s) for s in flat_specs) and
+      not all(_has_name(s) for s in flat_specs))
+
+  if name_inconsistency:
+    specs = nest.map_structure(_clear_name, specs)
+  return specs
+
+
+def model_input_signature(model, keep_original_batch_size=False):
+  """Inspect model to get its input signature.
+
+  The model's input signature is a list with a single (possibly-nested) object.
+  This is due to the Keras-enforced restriction that tensor inputs must be
+  passed in as the first argument.
+
+  For example, a model with input {'feature1': <Tensor>, 'feature2': <Tensor>}
+  will have input signature: [{'feature1': TensorSpec, 'feature2': TensorSpec}]
+
+  Args:
+    model: Keras Model object.
+    keep_original_batch_size: A boolean indicating whether we want to keep using
+      the original batch size or set it to None. Default is `False`, which means
+      that the batch dim of the returned input signature will always be set to
+      `None`.
+
+  Returns:
+    A list containing either a single TensorSpec or an object with nested
+    TensorSpecs. This list does not contain the `training` argument.
+  """
+  if hasattr(model, 'save_spec'):
+    input_specs = model.save_spec(dynamic_batch=not keep_original_batch_size)
+    if input_specs is None:
+      return None
+    # The model's save spec returns (args, kwargs). Extract the first input arg
+    # to use as the input spec.
+    # TODO(b/188105669): Add support for multiple tensor arguments.
+    input_specs = input_specs[0][0]
+  else:
+    input_specs = model._get_save_spec(  # pylint: disable=protected-access
+        dynamic_batch=not keep_original_batch_size)
+    if input_specs is None:
+      return None
+  input_specs = _enforce_names_consistency(input_specs)
+  # Return a list with a single element as the model's input signature.
+  if isinstance(input_specs,
+                collections_abc.Sequence) and len(input_specs) == 1:
+    # Note that the isinstance check filters out single-element dictionaries,
+    # which should also be wrapped as a single-element list.
+    return input_specs
+  else:
+    return [input_specs]
+
+
+def raise_model_input_error(model):
+  raise ValueError(
+      'Model {} cannot be saved because the input shapes have not been '
+      'set. Usually, input shapes are automatically determined from calling'
+      ' `.fit()` or `.predict()`. To manually set the shapes, call '
+      '`model.build(input_shape)`.'.format(model))
+
+
+def _create_pseudo_names(tensors, prefix):
+  """Creates pseudo {input | output} names for subclassed Models.
+
+  Warning: this function should only be used to define default
+  names for `Metics` and `SavedModel`. No other use cases should
+  rely on a `Model`'s input or output names.
+
+  Example with dict:
+
+  `{'a': [x1, x2], 'b': x3}` becomes:
+  `['a_1', 'a_2', 'b']`
+
+  Example with list:
+
+  `[x, y]` becomes:
+  `['output_1', 'output_2']`
+
+  Args:
+    tensors: `Model`'s outputs or inputs.
+    prefix: 'output_' for outputs, 'input_' for inputs.
+
+  Returns:
+    Flattened list of pseudo names.
+  """
+
+  def one_index(ele):
+    # Start with "output_1" instead of "output_0".
+    if isinstance(ele, int):
+      return ele + 1
+    return ele
+
+  flat_paths = list(nest.yield_flat_paths(tensors))
+  flat_paths = nest.map_structure(one_index, flat_paths)
+  names = []
+  for path in flat_paths:
+    if not path:
+      name = prefix + '1'  # Single output.
+    else:
+      name = '_'.join(str(p) for p in path)
+      if isinstance(path[0], int):
+        name = prefix + name
+    names.append(name)
+  return names
+
+
+def create_pseudo_output_names(outputs):
+  """Create pseudo output names for a subclassed Model."""
+  return _create_pseudo_names(outputs, prefix='output_')
+
+
+def trace_model_call(model, input_signature=None):
+  """Trace the model call to create a tf.function for exporting a Keras model.
+
+  Args:
+    model: A Keras model.
+    input_signature: optional, a list of tf.TensorSpec objects specifying the
+      inputs to the model.
+
+  Returns:
+    A tf.function wrapping the model's call function with input signatures set.
+
+  Raises:
+    ValueError: if input signature cannot be inferred from the model.
+  """
+  if input_signature is None:
+    if isinstance(model.call, def_function.Function):
+      input_signature = model.call.input_signature
+
+  if input_signature is None:
+    input_signature = model_input_signature(model)
+
+  if input_signature is None:
+    raise_model_input_error(model)
+
+  @def_function.function(input_signature=input_signature, autograph=False)
+  def _wrapped_model(*args):
+    """A concrete tf.function that wraps the model's call function."""
+    # When given a single input, Keras models will call the model on the tensor
+    # rather than a list consisting of the single tensor.
+    inputs = args[0] if len(input_signature) == 1 else list(args)
+
+    with keras_deps.get_call_context_function()().enter(
+        model, inputs=inputs, build_graph=False, training=False, saving=True):
+      outputs = model(inputs, training=False)
+
+    return outputs
+
+  return _wrapped_model

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

@@ -0,0 +1,1070 @@
+# 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.
+# ==============================================================================
+"""Functions used by multiple converter files."""
+
+import copy
+import datetime
+import sys
+
+from absl import logging
+import flatbuffers
+
+from tensorflow.core.protobuf import config_pb2 as _config_pb2
+from tensorflow.core.protobuf import meta_graph_pb2 as _meta_graph_pb2
+from tensorflow.lite.python import conversion_metadata_schema_py_generated as conversion_metadata_fb
+from tensorflow.lite.python import schema_py_generated as schema_fb
+from tensorflow.lite.python import schema_util
+from tensorflow.lite.python import tflite_keras_util as _tflite_keras_util
+from tensorflow.lite.python.op_hint import convert_op_hints_to_stubs
+from tensorflow.lite.python.op_hint import find_all_hinted_output_nodes
+from tensorflow.lite.tools import flatbuffer_utils
+from tensorflow.python.eager import function
+from tensorflow.python.framework import convert_to_constants as _convert_to_constants
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import error_interpolation as _error_interpolation
+from tensorflow.python.grappler import tf_optimizer
+from tensorflow.python.training.saver import export_meta_graph as _export_meta_graph
+
+# The field name of conversion metadata in the flatbuffer file.
+CONVERSION_METADATA_FIELD_NAME = "CONVERSION_METADATA"
+
+# Keras functions used by TFLite
+model_input_signature = _tflite_keras_util.model_input_signature
+trace_model_call = _tflite_keras_util.trace_model_call
+
+# Jax functions used by TFLite
+# pylint: disable=g-import-not-at-top
+# pylint: disable=unused-import
+try:
+  from jax import xla_computation as _xla_computation
+except ImportError:
+  _xla_computation = None
+# pylint: enable=g-import-not-at-top
+# pylint: enable=unused-import
+
+# Defined as per TFLite schema
+_MAP_TFLITE_ENUM_TO_TF_TYPES = {
+    0: dtypes.float32,
+    1: dtypes.float16,
+    2: dtypes.int32,
+    3: dtypes.uint8,
+    4: dtypes.int64,
+    5: dtypes.string,
+    6: dtypes.bool,
+    7: dtypes.int16,
+    8: dtypes.complex64,
+    9: dtypes.int8,
+    10: dtypes.float64,
+    11: dtypes.complex128,
+    16: dtypes.uint32,
+}
+
+_TFLITE_FILE_IDENTIFIER = b"TFL3"
+
+_MAP_QUANT_TO_IO_TYPES = {
+    dtypes.int8: {dtypes.int8, dtypes.uint8},
+    dtypes.int16: {dtypes.int16},
+}
+
+
+def _convert_tflite_enum_type_to_tf_type(tflite_enum_type):
+  """Converts tflite enum type (eg: 0) to tf type (eg: tf.float32).
+
+  Args:
+    tflite_enum_type: tflite enum type (eg: 0, that corresponds to float32)
+
+  Raises:
+    ValueError: If an invalid tflite enum type is provided.
+
+  Returns:
+    tf type (eg: tf.float32)
+  """
+  tf_type = _MAP_TFLITE_ENUM_TO_TF_TYPES.get(tflite_enum_type)
+  if tf_type is None:
+    raise ValueError(
+        "Unsupported enum {}. The valid map of enum to tf types is : {}"
+        .format(tflite_enum_type, _MAP_TFLITE_ENUM_TO_TF_TYPES))
+  return tf_type
+
+
+def get_tf_type_name(tf_type):
+  """Converts tf.dtype (eg: tf.float32) to str (eg: "tf.float32")."""
+  return "tf." + tf_type.name if tf_type else None
+
+
+def get_tensor_name(tensor):
+  """Returns name of the input tensor.
+
+  Args:
+    tensor: tf.Tensor
+
+  Returns:
+    str
+  """
+  parts = tensor.name.split(":")
+  if len(parts) > 2:
+    raise ValueError("Tensor name invalid. Expect 0 or 1 colon, got {0}".format(
+        len(parts) - 1))
+
+  # To be consistent with the tensor naming scheme in tensorflow, we need
+  # drop the ':0' suffix for the first tensor.
+  if len(parts) > 1 and parts[1] != "0":
+    return tensor.name
+  return parts[0]
+
+
+def get_tensors_from_tensor_names(graph, tensor_names):
+  """Gets the Tensors associated with the `tensor_names` in the provided graph.
+
+  Args:
+    graph: TensorFlow Graph.
+    tensor_names: List of strings that represent names of tensors in the graph.
+
+  Returns:
+    A list of Tensor objects in the same order the names are provided.
+
+  Raises:
+    ValueError:
+      tensor_names contains an invalid tensor name.
+  """
+  # Get the list of all of the tensors.
+  tensor_name_to_tensor = {}
+  for op in graph.get_operations():
+    for tensor in op.values():
+      tensor_name_to_tensor[get_tensor_name(tensor)] = tensor
+
+  # Get the tensors associated with tensor_names.
+  tensors = []
+  invalid_tensors = []
+  for name in tensor_names:
+    if not isinstance(name, str):
+      raise ValueError("Invalid type for a tensor name in the provided graph. "
+                       "Expected type for a tensor name is 'str', instead got "
+                       "type '{}' for tensor name '{}'".format(
+                           type(name), name))
+
+    tensor = tensor_name_to_tensor.get(name)
+    if tensor is None:
+      invalid_tensors.append(name)
+    else:
+      tensors.append(tensor)
+
+  # Throw ValueError if any user input names are not valid tensors.
+  if invalid_tensors:
+    raise ValueError("Invalid tensors '{}' were found.".format(
+        ",".join(invalid_tensors)))
+  return tensors
+
+
+def set_tensor_shapes(tensors, shapes):
+  """Sets Tensor shape for each tensor if the shape is defined.
+
+  Args:
+    tensors: TensorFlow tensor.Tensor.
+    shapes: Dict of strings representing input tensor names to list of
+      integers representing input shapes (e.g., {"foo": : [1, 16, 16, 3]}).
+
+  Raises:
+    ValueError:
+      `shapes` contains an invalid tensor.
+      `shapes` contains an invalid shape for a valid tensor.
+  """
+  if shapes:
+    tensor_names_to_tensor = {
+        get_tensor_name(tensor): tensor for tensor in tensors
+    }
+    for name, shape in shapes.items():
+      if name not in tensor_names_to_tensor:
+        raise ValueError("Invalid tensor \'{}\' found in tensor shapes "
+                         "map.".format(name))
+      if shape is not None:
+        tensor = tensor_names_to_tensor[name]
+        try:
+          tensor.set_shape(shape)
+        except ValueError as error:
+          message = ("The shape of tensor '{0}' cannot be changed from {1} to "
+                     "{2}. {3}".format(name, tensor.shape, shape, str(error)))
+          raise ValueError(message)
+
+
+def get_grappler_config(optimizers_list):
+  """Creates a tf.compat.v1.ConfigProto for configuring Grappler.
+
+  Args:
+    optimizers_list: List of strings that represents the list of optimizers.
+
+  Returns:
+    tf.ConfigProto.
+  """
+  config = _config_pb2.ConfigProto()
+  rewrite_options = config.graph_options.rewrite_options
+  for optimizer in optimizers_list:
+    rewrite_options.optimizers.append(optimizer)
+  return config
+
+
+def run_graph_optimizations(graph_def,
+                            input_arrays,
+                            output_arrays,
+                            config,
+                            graph=None):
+  """Apply standard TensorFlow optimizations to the graph_def.
+
+  Args:
+    graph_def: Frozen GraphDef to be optimized.
+    input_arrays: List of arrays that are considered inputs of the graph.
+    output_arrays: List of arrays that are considered outputs of the graph.
+    config: tf.ConfigProto.
+    graph: TensorFlow Graph. Required when Eager mode is enabled. (default None)
+
+  Returns:
+    A new, optimized GraphDef.
+  """
+  meta_graph = _export_meta_graph(graph_def=graph_def, graph=graph)
+
+  signature = _meta_graph_pb2.SignatureDef()
+  for array in input_arrays:
+    signature.inputs[array.name].name = array.name
+    signature.inputs[array.name].dtype = array.dtype.as_datatype_enum
+    signature.inputs[array.name].tensor_shape.CopyFrom(array.shape.as_proto())
+
+  for array in output_arrays:
+    signature.outputs[array.name].name = array.name
+    signature.outputs[array.name].dtype = array.dtype.as_datatype_enum
+    signature.outputs[array.name].tensor_shape.CopyFrom(array.shape.as_proto())
+
+  meta_graph.signature_def["not_used_key"].CopyFrom(signature)
+
+  # We need to add a collection called 'train_op' so that grappler
+  # knows what the outputs are.
+  fetch_collection = _meta_graph_pb2.CollectionDef()
+  for array in input_arrays + output_arrays:
+    fetch_collection.node_list.value.append(array.name)
+  meta_graph.collection_def["train_op"].CopyFrom(fetch_collection)
+
+  return tf_optimizer.OptimizeGraph(config, meta_graph)
+
+
+def _convert_op_hints_if_present(sess, graph_def, output_tensors,
+                                 hinted_outputs_nodes):
+  if is_frozen_graph(sess):
+    raise ValueError("Try to convert op hints, needs unfrozen graph.")
+  output_arrays = [get_tensor_name(tensor) for tensor in output_tensors]
+  graph_def = _convert_to_constants.convert_variables_to_constants(
+      sess, graph_def, output_arrays + hinted_outputs_nodes)
+  graph_def = convert_op_hints_to_stubs(graph_def=graph_def)
+  return graph_def
+
+
+def freeze_graph(sess, input_tensors, output_tensors):
+  """Returns a frozen GraphDef.
+
+  Runs a Grappler pass and freezes a graph with Variables in it. Otherwise the
+  existing GraphDef is returned. The Grappler pass is only run on models that
+  are frozen in order to inline the functions in the graph.
+  If OpHints is present, it will try to convert the OpHint graph.
+
+  Args:
+    sess: TensorFlow Session.
+    input_tensors: List of input tensors.
+    output_tensors: List of output tensors (only .name is used from this).
+
+  Returns:
+    Frozen GraphDef.
+  """
+  # Runs a Grappler pass in order to inline any functions in the graph.
+  # Asides from inlining any simple function, Grappler will also try to lower
+  # while loop into switch merge representation which is undesired for Ophints,
+  # so we simply remove those attributes to prevent Grappler from doing so.
+  graph_def = _convert_to_constants.disable_lower_using_switch_merge(
+      sess.graph_def)
+  config = get_grappler_config(["function"])
+  graph_def = run_graph_optimizations(
+      graph_def, input_tensors, output_tensors, config, graph=sess.graph)
+
+  # If ophints are present, just convert them.
+  hinted_outputs_nodes = find_all_hinted_output_nodes(sess)
+  if hinted_outputs_nodes:
+    return _convert_op_hints_if_present(sess, graph_def, output_tensors,
+                                        hinted_outputs_nodes)
+
+  if not is_frozen_graph(sess):
+    output_node_names = [tensor.name.split(":")[0] for tensor in output_tensors]
+    return _convert_to_constants.convert_variables_to_constants(
+        sess, graph_def, output_node_names
+    )
+  else:
+    return sess.graph_def
+
+
+def is_frozen_graph(sess):
+  """Determines if the graph is frozen.
+
+  Determines if a graph has previously been frozen by checking for any
+  operations of type Variable*. If variables are found, the graph is not frozen.
+
+  Args:
+    sess: TensorFlow Session.
+
+  Returns:
+    Bool.
+  """
+  for op in sess.graph.get_operations():
+    if op.type.startswith("Variable") or op.type.endswith("VariableOp"):
+      return False
+  return True
+
+
+def build_debug_info_func(original_graph):
+  """Returns a method to retrieve the `GraphDebugInfo` from the original graph.
+
+  Args:
+    original_graph: The original `Graph` containing all the op stack traces.
+
+  Returns:
+    A function which retrieves the stack traces from the original graph and
+    converts them to a `GraphDebugInfo` for a given set of nodes.
+  """
+
+  def f(original_nodes):
+    """Function to create `GraphDebugInfo` for the given `original_nodes`."""
+    if not original_graph:
+      return None
+    # For the given nodes, gets all the op definitions in the original graph.
+    useful_ops = []
+    for func, name in original_nodes:
+      try:
+        if not func:
+          useful_ops.append((func, original_graph.get_operation_by_name(name)))
+        else:
+          sub_func = original_graph._get_function(func)  # pylint: disable=protected-access
+          if isinstance(sub_func, function.AtomicFunction):  # pylint: disable=protected-access
+            useful_ops.append(
+                (func, sub_func.graph.get_operation_by_name(name)))
+          else:
+            sys.stderr.write(
+                "Use '@tf.function' or '@defun' to decorate the function.\n")
+            continue
+      except KeyError:
+        # New node created by graph optimizer. No stack trace from source code.
+        continue
+    # Convert all the op definitions to stack traces in terms of GraphDebugInfo.
+    return _error_interpolation.create_graph_debug_info_def(useful_ops)
+
+  return f
+
+
+def convert_debug_info_func(saved_debug_info):
+  """Returns a method to retrieve the `GraphDebugInfo` from the original graph.
+
+  Args:
+    saved_debug_info: The `GraphDebugInfo` containing all the debug info.
+
+  Returns:
+    A function which retrieves the stack traces from the original graph and
+    converts them to a `GraphDebugInfo` for a given set of nodes.
+  """
+
+  def f(original_nodes):
+    """Function to create `GraphDebugInfo` for the given `original_nodes`."""
+    del original_nodes
+    return saved_debug_info
+
+  return f
+
+
+def get_debug_info(nodes_to_debug_info_func, converted_graph):
+  """Returns the debug info for the original nodes in the `converted_graph`.
+
+  Args:
+    nodes_to_debug_info_func: The method to collect the op debug info for the
+      nodes.
+    converted_graph: A `GraphDef` after optimization and transformation.
+
+  Returns:
+    `GraphDebugInfo` for all the original nodes in `converted_graph`.
+  """
+  if not nodes_to_debug_info_func:
+    return None
+
+  # Collect all the debug info nodes from the converted_graph
+  original_nodes = set()
+  for node in converted_graph.node:
+    debug_nodes = node.experimental_debug_info.original_node_names
+    debug_funcs = node.experimental_debug_info.original_func_names
+    # If the `original_node_names` are empty, uses the node name directly.
+    if not debug_nodes:
+      original_nodes.add(("", node.name))
+    else:
+      for i in range(len(debug_nodes)):
+        debug_func = "" if i >= len(debug_funcs) else debug_funcs[i]
+        original_nodes.add((debug_func, debug_nodes[i]))
+
+  # Convert the nodes to the debug info proto object.
+  return nodes_to_debug_info_func(original_nodes)
+
+
+def convert_bytes_to_c_source(data,
+                              array_name,
+                              max_line_width=80,
+                              include_guard=None,
+                              include_path=None,
+                              use_tensorflow_license=False):
+  """Returns strings representing a C constant array containing `data`.
+
+  Args:
+    data: Byte array that will be converted into a C constant.
+    array_name: String to use as the variable name for the constant array.
+    max_line_width: The longest line length, for formatting purposes.
+    include_guard: Name to use for the include guard macro definition.
+    include_path: Optional path to include in the source file.
+    use_tensorflow_license: Whether to include the standard TensorFlow Apache2
+      license in the generated files.
+
+  Returns:
+    Text that can be compiled as a C source file to link in the data as a
+    literal array of values.
+    Text that can be used as a C header file to reference the literal array.
+  """
+
+  starting_pad = "   "
+  array_lines = []
+  array_line = starting_pad
+  for value in bytearray(data):
+    if (len(array_line) + 4) > max_line_width:
+      array_lines.append(array_line + "\n")
+      array_line = starting_pad
+    array_line += " 0x%02x," % (value,)
+  if len(array_line) > len(starting_pad):
+    array_lines.append(array_line + "\n")
+  array_values = "".join(array_lines)
+
+  if include_guard is None:
+    include_guard = "TENSORFLOW_LITE_UTIL_" + array_name.upper() + "_DATA_H_"
+
+  if include_path is not None:
+    include_line = "#include \"{include_path}\"\n".format(
+        include_path=include_path)
+  else:
+    include_line = ""
+
+  if use_tensorflow_license:
+    license_text = """
+/* Copyright {year} 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.
+==============================================================================*/
+""".format(year=datetime.date.today().year)
+  else:
+    license_text = ""
+
+  source_template = """{license_text}
+// This is a TensorFlow Lite model file that has been converted into a C data
+// array using the tensorflow.lite.util.convert_bytes_to_c_source() function.
+// This form is useful for compiling into a binary for devices that don't have a
+// file system.
+
+{include_line}
+// We need to keep the data array aligned on some architectures.
+#ifdef __has_attribute
+#define HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define HAVE_ATTRIBUTE(x) 0
+#endif
+#if HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+#define DATA_ALIGN_ATTRIBUTE __attribute__((aligned(4)))
+#else
+#define DATA_ALIGN_ATTRIBUTE
+#endif
+
+const unsigned char {array_name}[] DATA_ALIGN_ATTRIBUTE = {{
+{array_values}}};
+const int {array_name}_len = {array_length};
+"""
+
+  source_text = source_template.format(
+      array_name=array_name,
+      array_length=len(data),
+      array_values=array_values,
+      license_text=license_text,
+      include_line=include_line)
+
+  header_template = """
+{license_text}
+
+// This is a TensorFlow Lite model file that has been converted into a C data
+// array using the tensorflow.lite.util.convert_bytes_to_c_source() function.
+// This form is useful for compiling into a binary for devices that don't have a
+// file system.
+
+#ifndef {include_guard}
+#define {include_guard}
+
+extern const unsigned char {array_name}[];
+extern const int {array_name}_len;
+
+#endif  // {include_guard}
+"""
+
+  header_text = header_template.format(
+      array_name=array_name,
+      include_guard=include_guard,
+      license_text=license_text)
+
+  return source_text, header_text
+
+
+def _convert_model_from_bytearray_to_object(model_bytearray):
+  """Converts a tflite model from a bytearray into a parsable object."""
+  model_object = schema_fb.Model.GetRootAsModel(model_bytearray, 0)
+  model_object = schema_fb.ModelT.InitFromObj(model_object)
+  model_object = copy.deepcopy(model_object)
+  return model_object
+
+
+def _convert_model_from_object_to_bytearray(model_object):
+  """Converts a tflite model from a parsable object into a bytearray."""
+  # Initial size of the buffer, which will grow automatically if needed
+  builder = flatbuffers.Builder(1024)
+  model_offset = model_object.Pack(builder)
+  builder.Finish(model_offset, file_identifier=_TFLITE_FILE_IDENTIFIER)
+  return bytes(builder.Output())
+
+
+def get_quantize_opcode_idx(model):
+  """Returns the quantize op idx."""
+  quant_opcode_idxs = []
+  for idx, opcode in enumerate(model.operatorCodes):
+    builtin_code = schema_util.get_builtin_code_from_operator_code(opcode)
+    if builtin_code == schema_fb.BuiltinOperator.QUANTIZE:
+      quant_opcode_idxs.append(idx)
+  return quant_opcode_idxs
+
+
+def get_dequantize_opcode_idx(model):
+  """Returns the quantize op idx."""
+  quant_opcode_idxs = []
+  for idx, opcode in enumerate(model.operatorCodes):
+    builtin_code = schema_util.get_builtin_code_from_operator_code(opcode)
+    if builtin_code == schema_fb.BuiltinOperator.DEQUANTIZE:
+      quant_opcode_idxs.append(idx)
+  return quant_opcode_idxs
+
+
+def _update_signature_def_tensors(tensor_maps, map_old_to_new_tensors):
+  """Update the tensors in the SignatureDef's TensorMaps."""
+  for i in range(len(tensor_maps)):
+    if tensor_maps[i].tensorIndex in map_old_to_new_tensors:
+      tensor_maps[i].tensorIndex = (
+          map_old_to_new_tensors[tensor_maps[i].tensorIndex])
+
+
+def _remove_tensors_from_model(model, remove_tensors_idxs):
+  """Remove tensors from model."""
+  if not remove_tensors_idxs:
+    return
+  if len(model.subgraphs) > 1:
+    logging.info("Skipping the removal of dangled tensors since the model has "
+                 "multiple subgraphs and tensors can be used in the different "
+                 "subgraph(s)")
+    return
+  subgraph = model.subgraphs[0]
+  tensors = subgraph.tensors
+  operators = subgraph.operators
+
+  logging.debug("Removing tensors at indices : %s", remove_tensors_idxs)
+  # An optimized check to validate if "remove_tensors_idxs" (eg: [4,5,6]) is an
+  # exact subset, with ordering, of "tensors" indices (eg: [0,1,2,3,4,5,6]).
+  if min(remove_tensors_idxs) == len(tensors) - len(remove_tensors_idxs):
+    logging.debug("Removing tensors only at the end of the tensor list")
+    del tensors[min(remove_tensors_idxs):]
+  else:
+    logging.debug("Removing tensors requires updating the model")
+    # Map the old tensor indices to new tensor indices
+    d_old_to_new_tensors = {}
+    left_shift_by = 0
+    for idx in range(len(tensors)):
+      if idx in remove_tensors_idxs:
+        left_shift_by += 1
+      else:
+        d_old_to_new_tensors[idx] = idx - left_shift_by
+    logging.debug("Old to new tensors map: %s", d_old_to_new_tensors.__str__())
+    # Update tensor indices referenced throughout the model
+    def update_tensors(tensor_idxs):
+      for i, ti in enumerate(tensor_idxs):
+        tensor_idxs[i] = d_old_to_new_tensors.get(ti, -1)
+    update_tensors(subgraph.inputs)
+    update_tensors(subgraph.outputs)
+    for op in operators:
+      update_tensors(op.inputs)
+      update_tensors(op.outputs)
+    if model.signatureDefs:
+      signature_def = model.signatureDefs[0]
+      _update_signature_def_tensors(signature_def.inputs, d_old_to_new_tensors)
+      _update_signature_def_tensors(signature_def.outputs, d_old_to_new_tensors)
+    # Delete the tensors
+    for idx in sorted(remove_tensors_idxs, reverse=True):
+      tensors.pop(idx)
+    logging.debug("Removed tensors marked for deletion")
+
+
+def _modify_model_input_type(model, inference_input_type=dtypes.float32):
+  """Modify model input type."""
+  if inference_input_type == dtypes.float32:
+    return
+
+  if not model.signatureDefs:
+    _modify_model_input_type_per_subgraph(model, 0, -1, inference_input_type)
+    return
+
+  for signature_index, signature_def in enumerate(model.signatureDefs):
+    _modify_model_input_type_per_subgraph(model, signature_def.subgraphIndex,
+                                          signature_index, inference_input_type)
+
+
+def _modify_model_input_type_per_subgraph(model, subgraph_index,
+                                          signature_index,
+                                          inference_input_type):
+  """Modify model input type per subgraph."""
+  subgraph = model.subgraphs[subgraph_index]
+  tensors = subgraph.tensors
+  operators = subgraph.operators
+
+  # Find all quantize operators
+  quant_opcode_idxs = get_quantize_opcode_idx(model)
+  if operators and not quant_opcode_idxs:
+    for input_idx in subgraph.inputs:
+      input_type = _convert_tflite_enum_type_to_tf_type(tensors[input_idx].type)
+      if input_type == dtypes.float32:
+        raise ValueError("Model input is not dequantized.")
+    # None of the inputs have float32, then they must be int16, int8, or bool
+    return
+
+  # Validate that the model input is quantized
+  input_quant_ops = []
+  for op in operators:
+    # Find operators that quantize model input
+    if op.opcodeIndex in quant_opcode_idxs and op.inputs[0] in subgraph.inputs:
+      float_tensor, quant_tensor = tensors[op.inputs[0]], tensors[op.outputs[0]]
+      # If found, validate that the operator's input type is float
+      float_type = _convert_tflite_enum_type_to_tf_type(float_tensor.type)
+      if float_type != dtypes.float32:
+        if float_type == inference_input_type:
+          continue
+        else:
+          raise ValueError(
+              "Initial model input type must be tf.float32. Expected type for "
+              "tensor with name '{}' is tf.float32, instead type is {}".format(
+                  float_tensor.name, get_tf_type_name(float_type)))
+      # If found, validate that the operator output is quantized and compatible
+      # with the final model input type
+      quant_type = _convert_tflite_enum_type_to_tf_type(quant_tensor.type)
+      if quant_type not in _MAP_QUANT_TO_IO_TYPES:
+        raise ValueError(
+            "Initial model input is not quantized. Expected type for "
+            "tensor with name '{}' should be in {}, instead type is {}".format(
+                quant_tensor.name,
+                tuple(get_tf_type_name(t) for t in
+                      _MAP_QUANT_TO_IO_TYPES.keys()),
+                get_tf_type_name(quant_type)))
+      else:
+        inference_io_types = _MAP_QUANT_TO_IO_TYPES[quant_type]
+        if inference_input_type not in inference_io_types:
+          raise ValueError(
+              "Unsupported `inference_input_type` value. Expected to be in "
+              "{}, instead got {}.".format(
+                  tuple(get_tf_type_name(t) for t in inference_io_types),
+                  get_tf_type_name(inference_input_type)))
+      input_quant_ops.append(op)
+
+  if len(subgraph.inputs) != len(input_quant_ops):
+    logging.warning(
+        "For model inputs containing unsupported operations which cannot be "
+        "quantized, the `inference_input_type` attribute will default to the "
+        "original type."
+        )
+
+  # Modify model input type
+  if inference_input_type == dtypes.uint8:
+    # Change quant op (float to int8) to quant op (uint8 to int8)
+    for op in input_quant_ops:
+      int8_quantization = tensors[op.outputs[0]].quantization
+      uint8_quantization = schema_fb.QuantizationParametersT()
+      uint8_quantization.scale = [int8_quantization.scale[0]]
+      uint8_quantization.zeroPoint = [int8_quantization.zeroPoint[0] + 128]
+      tensors[op.inputs[0]].quantization = uint8_quantization
+      tensors[op.inputs[0]].type = schema_fb.TensorType.UINT8
+  elif inference_input_type in _MAP_QUANT_TO_IO_TYPES:
+    # Remove the inputs and the quant operator
+    remove_tensors_idxs = set()
+    for op in input_quant_ops:
+      subgraph.inputs[subgraph.inputs == op.inputs[0]] = op.outputs[0]
+      if signature_index >= 0:
+        signature_def = model.signatureDefs[signature_index]
+        for i in range(len(signature_def.inputs)):
+          if signature_def.inputs[i].tensorIndex == op.inputs[0]:
+            signature_def.inputs[i].tensorIndex = op.outputs[0]
+      remove_tensors_idxs.add(op.inputs[0])
+      operators.remove(op)
+    # Remove tensors marked for deletion.
+    _remove_tensors_from_model(model, remove_tensors_idxs)
+  else:
+    raise ValueError(
+        "Unsupported `inference_input_type` value {}.".format(
+            get_tf_type_name(inference_input_type)))
+
+
+def _modify_model_output_type(model, inference_output_type=dtypes.float32):
+  """Modify model output type."""
+  if inference_output_type == dtypes.float32:
+    return
+
+  if not model.signatureDefs:
+    _modify_model_output_type_per_subgraph(model, 0, -1, inference_output_type)
+    return
+
+  for signature_index, signature_def in enumerate(model.signatureDefs):
+    _modify_model_output_type_per_subgraph(model, signature_def.subgraphIndex,
+                                           signature_index,
+                                           inference_output_type)
+
+
+def _modify_model_output_type_per_subgraph(model, subgraph_index,
+                                           signature_index,
+                                           inference_output_type):
+  """Modify model output type per subgraph."""
+  subgraph = model.subgraphs[subgraph_index]
+  tensors = subgraph.tensors
+  operators = subgraph.operators
+
+  # Find all dequantize operators
+  dequant_opcode_idxs = get_dequantize_opcode_idx(model)
+  if operators and not dequant_opcode_idxs:
+    for output in subgraph.outputs:
+      output_type = _convert_tflite_enum_type_to_tf_type(tensors[output].type)
+      if output_type == dtypes.float32:
+        raise ValueError("Model output is not dequantized.")
+    # None of the outputs have float32, then they must be int16, int8, or bool
+    return
+
+  # Validate that the model output is dequantized
+  output_dequant_ops = []
+  for op in operators:
+    # Find operators that dequantize model output
+    if (op.opcodeIndex in dequant_opcode_idxs and
+        op.outputs[0] in subgraph.outputs):
+      # If found, validate that the operator's output type is float
+      quant_tensor, float_tensor = tensors[op.inputs[0]], tensors[op.outputs[0]]
+      float_type = _convert_tflite_enum_type_to_tf_type(float_tensor.type)
+      if float_type != dtypes.float32:
+        if float_type == inference_output_type:
+          continue
+        else:
+          raise ValueError(
+              "Initial model output type must be tf.float32. Expected type for "
+              "tensor with name '{}' is tf.float32, instead type is {}".format(
+                  float_tensor.name, get_tf_type_name(float_type)))
+      # If found, validate that the operator input is quantized and compatible
+      # with the final model output type
+      quant_type = _convert_tflite_enum_type_to_tf_type(quant_tensor.type)
+      if quant_type not in _MAP_QUANT_TO_IO_TYPES:
+        raise ValueError(
+            "Initial model output is not dequantized. Expected type for "
+            "tensor with name '{}' should be in {}, instead type is {}".format(
+                quant_tensor.name,
+                tuple(get_tf_type_name(t) for t in
+                      _MAP_QUANT_TO_IO_TYPES.keys()),
+                get_tf_type_name(quant_type)))
+      else:
+        inference_io_types = _MAP_QUANT_TO_IO_TYPES[quant_type]
+        if inference_output_type not in inference_io_types:
+          raise ValueError(
+              "Unsupported `inference_output_type` value. Expected to be in "
+              "{}, instead got {}.".format(
+                  tuple(get_tf_type_name(t) for t in inference_io_types),
+                  get_tf_type_name(inference_output_type)))
+      output_dequant_ops.append(op)
+
+  if len(subgraph.outputs) != len(output_dequant_ops):
+    logging.warning(
+        "For model outputs containing unsupported operations which cannot be "
+        "quantized, the `inference_output_type` attribute will default to the "
+        "original type."
+        )
+
+  # Modify model output type
+  if inference_output_type == dtypes.uint8:
+    # Find a quantize operator
+    quant_opcode_idx = -1
+    for idx, opcode in enumerate(model.operatorCodes):
+      builtin_code = schema_util.get_builtin_code_from_operator_code(opcode)
+      if builtin_code == schema_fb.BuiltinOperator.QUANTIZE:
+        quant_opcode_idx = idx
+        break
+    # Create a quantize operator, if none exist
+    if quant_opcode_idx == -1:
+      quant_op = schema_fb.OperatorCodeT()
+      quant_op.builtinCode = schema_fb.BuiltinOperator.QUANTIZE
+      quant_op.deprecatedBuiltinCode = schema_fb.BuiltinOperator.QUANTIZE
+      model.operatorCodes.append(quant_op)
+      quant_opcode_idx = len(model.operatorCodes) - 1
+    # Change dequant op (int8 to float) to quant op (int8 to uint8)
+    for op in output_dequant_ops:
+      op.opcodeIndex = quant_opcode_idx
+      int8_quantization = tensors[op.inputs[0]].quantization
+      uint8_quantization = schema_fb.QuantizationParametersT()
+      uint8_quantization.scale = [int8_quantization.scale[0]]
+      uint8_quantization.zeroPoint = [int8_quantization.zeroPoint[0] + 128]
+      tensors[op.outputs[0]].quantization = uint8_quantization
+      tensors[op.outputs[0]].type = schema_fb.TensorType.UINT8
+  elif inference_output_type in _MAP_QUANT_TO_IO_TYPES:
+    # Remove the outputs and the dequant operator
+    remove_tensors_idxs = set()
+    for op in output_dequant_ops:
+      subgraph.outputs[subgraph.outputs == op.outputs[0]] = op.inputs[0]
+      if signature_index >= 0:
+        signature_def = model.signatureDefs[signature_index]
+        for i in range(len(signature_def.outputs)):
+          if signature_def.outputs[i].tensorIndex == op.outputs[0]:
+            signature_def.outputs[i].tensorIndex = op.inputs[0]
+      remove_tensors_idxs.add(op.outputs[0])
+      operators.remove(op)
+    # Remove tensors marked for deletion.
+    _remove_tensors_from_model(model, remove_tensors_idxs)
+  else:
+    raise ValueError(
+        "Unsupported `inference_output_type` value {}.".format(
+            get_tf_type_name(inference_output_type)))
+
+
+def _remove_redundant_quantize_ops(model):
+  """Finds back to back quantize ops and remove the first quantize op."""
+  if not model.signatureDefs:
+    _remove_redundant_quantize_ops_per_subgraph(model, 0, -1)
+    return
+
+  for signature_index, signature_def in enumerate(model.signatureDefs):
+    _remove_redundant_quantize_ops_per_subgraph(model,
+                                                signature_def.subgraphIndex,
+                                                signature_index)
+
+
+def _remove_redundant_quantize_ops_per_subgraph(model, subgraph_index,
+                                                signature_index):
+  """Remove redundant quantize ops per subgraph."""
+  subgraph = model.subgraphs[subgraph_index]
+  tensors = subgraph.tensors
+  operators = subgraph.operators
+
+  # Find all quantize operators.
+  quant_opcode_idxs = get_quantize_opcode_idx(model)
+  dequant_opcode_idxs = get_dequantize_opcode_idx(model)
+
+  # Find all redundant quant tensors.
+  all_quant_ops = []
+  redundant_quant_tensors = {}
+  output_dequant_tensors = {}
+  for op in operators:
+    if op.opcodeIndex in quant_opcode_idxs:
+      all_quant_ops.append(op)
+      input_tensor = tensors[op.inputs[0]]
+      output_tensor = tensors[op.outputs[0]]
+      input_type = _convert_tflite_enum_type_to_tf_type(input_tensor.type)
+      output_type = _convert_tflite_enum_type_to_tf_type(output_tensor.type)
+      # This is a requantize op, so write down its input tensor index.
+      if input_type != dtypes.float32 and output_type != dtypes.float32:
+        redundant_quant_tensors[op.inputs[0]] = op
+    if (op.opcodeIndex in dequant_opcode_idxs and
+        op.outputs[0] in subgraph.outputs):
+      output_dequant_tensors[op.inputs[0]] = op
+
+  # Remove all the quant ops which produce the redundant quant tensors.
+  for op in all_quant_ops:
+    output_tensor_idx = op.outputs[0]
+    if output_tensor_idx in redundant_quant_tensors:
+      requantize_op = redundant_quant_tensors[output_tensor_idx]
+      if model.signatureDefs:
+        signature_def = model.signatureDefs[0]
+        for output in signature_def.outputs:
+          if output.tensorIndex == op.outputs[0]:
+            output.tensorIndex = op.inputs[0]
+      deleted_tensor = requantize_op.inputs[0]
+      # Reset the input of the requantize op to the float input
+      requantize_op.inputs[0] = op.inputs[0]
+      # Migrate other operator users to output tensor of requantize op
+      for op_user in operators:
+        if deleted_tensor in op_user.inputs and op_user != requantize_op:
+          for idx, input_tensor in enumerate(op_user.inputs):
+            if input_tensor == deleted_tensor:
+              op_user.inputs[idx] = requantize_op.outputs[0]
+      operators.remove(op)
+
+  # Remove all the quant ops which connect to the output dequant op.
+  for op in all_quant_ops:
+    output_tensor_idx = op.outputs[0]
+    if output_tensor_idx in output_dequant_tensors:
+      dequant_op = output_dequant_tensors[output_tensor_idx]
+      subgraph.outputs[subgraph.outputs == dequant_op.outputs[0]] = op.inputs[0]
+      if signature_index >= 0:
+        signature_def = model.signatureDefs[signature_index]
+        for output in signature_def.outputs:
+          if output.tensorIndex == dequant_op.outputs[0]:
+            output.tensorIndex = op.inputs[0]
+      operators.remove(op)
+      operators.remove(dequant_op)
+
+
+def modify_model_io_type(
+    model, inference_input_type=dtypes.float32,
+    inference_output_type=dtypes.float32):
+  """Modify the input/output type of a tflite model.
+
+  Args:
+    model: A tflite model.
+    inference_input_type: tf.DType representing modified input type.
+      (default tf.float32. If model input is int8 quantized, it must be in
+      {tf.float32, tf.int8,tf.uint8}, else if model input is int16 quantized,
+      it must be in {tf.float32, tf.int16}, else it must be tf.float32)
+    inference_output_type: tf.DType representing modified output type.
+      (default tf.float32. If model output is int8 dequantized, it must be in
+      {tf.float32, tf.int8,tf.uint8}, else if model output is int16 dequantized,
+      it must be in {tf.float32, tf.int16}, else it must be tf.float32)
+  Returns:
+    A tflite model with modified input/output type.
+
+  Raises:
+    ValueError: If `inference_input_type`/`inference_output_type` is unsupported
+      or a supported integer type is specified for a model whose input/output is
+      not quantized/dequantized.
+    RuntimeError: If the modification was unsuccessful.
+
+  """
+  if (inference_input_type == dtypes.float32 and
+      inference_output_type == dtypes.float32):
+    return model
+
+  model_object = _convert_model_from_bytearray_to_object(model)
+
+  _modify_model_input_type(model_object, inference_input_type)
+
+  _modify_model_output_type(model_object, inference_output_type)
+
+  _remove_redundant_quantize_ops(model_object)
+
+  return _convert_model_from_object_to_bytearray(model_object)
+
+
+def get_sparsity_modes(model_object):
+  """Get sparsity modes used in a tflite model.
+
+  The sparsity modes are listed in conversion_metadata.fbs file.
+
+  Args:
+    model_object: A tflite model in object form.
+
+  Returns:
+    The list of sparsity modes used in the model.
+  """
+  if not model_object or not model_object.metadata:
+    return []
+
+  result = set()
+  for subgraph in model_object.subgraphs:
+    for tensor in subgraph.tensors:
+      if not tensor.sparsity:
+        continue
+
+      # Block map is the list if indexes where the block size is larger than 1.
+      # So empty block map means it is random sparsity.
+      if not tensor.sparsity.blockMap:
+        result.add(
+            conversion_metadata_fb.ModelOptimizationMode.RANDOM_SPARSITY)
+      else:
+        result.add(
+            conversion_metadata_fb.ModelOptimizationMode.BLOCK_SPARSITY)
+
+  return list(result)
+
+
+def populate_conversion_metadata(model_object, metadata):
+  """Add or update conversion metadata to a tflite model.
+
+  Args:
+    model_object: A tflite model in object form.
+    metadata: The conversion metadata.
+
+  Returns:
+    A tflite model object with embedded conversion metadata.
+  """
+  try:
+    metadata_builder = flatbuffers.Builder(0)
+    metadata_builder.Finish(metadata.Pack(metadata_builder))
+    buffer_field = schema_fb.BufferT()
+    buffer_field.data = metadata_builder.Output()
+
+    if not model_object.metadata:
+      model_object.metadata = []
+    else:
+      # Check if metadata has already been populated.
+      for meta in model_object.metadata:
+        if meta.name.decode("utf-8") == CONVERSION_METADATA_FIELD_NAME:
+          model_object.buffers[meta.buffer] = buffer_field
+          return model_object
+
+    if not model_object.buffers:
+      model_object.buffers = []
+    model_object.buffers.append(buffer_field)
+    # Creates a new metadata field.
+    metadata_field = schema_fb.MetadataT()
+    metadata_field.name = CONVERSION_METADATA_FIELD_NAME
+    metadata_field.buffer = len(model_object.buffers) - 1
+    model_object.metadata.append(metadata_field)
+
+    return model_object
+  except Exception:  # pylint: disable=broad-except
+    return model_object
+
+
+def get_conversion_metadata(model_buffer):
+  """Read conversion metadata from a tflite model.
+
+  Args:
+    model_buffer: A tflite model.
+
+  Returns:
+    The conversion metadata or None if it is not populated.
+  """
+  model_object = flatbuffer_utils.convert_bytearray_to_object(model_buffer)
+  if not model_object or not model_object.metadata:
+    return None
+
+  for meta in model_object.metadata:
+    if meta.name.decode("utf-8") == CONVERSION_METADATA_FIELD_NAME:
+      metadata_buf = model_object.buffers[meta.buffer].data.tobytes()
+      return conversion_metadata_fb.ConversionMetadataT.InitFromObj(
+          conversion_metadata_fb.ConversionMetadata.GetRootAsConversionMetadata(
+              metadata_buf, 0))
+
+  return None

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/python/wrap_toco.py

@@ -0,0 +1,66 @@
+# 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.
+# ==============================================================================
+"""Wraps toco interface with python lazy loader."""
+# We need to import pywrap_tensorflow prior to the toco wrapper.
+# pylint: disable=invalid-import-order,g-bad-import-order
+from tensorflow.python import pywrap_tensorflow  # pylint: disable=unused-import
+from tensorflow.python import _pywrap_toco_api
+
+# TODO(b/137402359): Remove lazy loading wrapper
+
+
+def wrapped_toco_convert(model_flags_str, toco_flags_str, input_data_str,
+                         debug_info_str, enable_mlir_converter):
+  """Wraps TocoConvert with lazy loader."""
+  return _pywrap_toco_api.TocoConvert(
+      model_flags_str,
+      toco_flags_str,
+      input_data_str,
+      False,  # extended_return
+      debug_info_str,
+      enable_mlir_converter)
+
+
+def wrapped_experimental_mlir_quantize(
+    input_data_str, disable_per_channel, fully_quantize, inference_type,
+    input_data_type, output_data_type, enable_numeric_verify,
+    enable_whole_model_verify, denylisted_ops, denylisted_nodes,
+    enable_variable_quantization):
+  """Wraps experimental mlir quantize model."""
+  return _pywrap_toco_api.ExperimentalMlirQuantizeModel(
+      input_data_str, disable_per_channel, fully_quantize, inference_type,
+      input_data_type, output_data_type, enable_numeric_verify,
+      enable_whole_model_verify, denylisted_ops, denylisted_nodes,
+      enable_variable_quantization)
+
+
+def wrapped_experimental_mlir_sparsify(input_data_str):
+  """Wraps experimental mlir sparsify model."""
+  return _pywrap_toco_api.ExperimentalMlirSparsifyModel(input_data_str)
+
+
+def wrapped_register_custom_opdefs(custom_opdefs_list):
+  """Wraps RegisterCustomOpdefs with lazy loader."""
+  return _pywrap_toco_api.RegisterCustomOpdefs(custom_opdefs_list)
+
+
+def wrapped_retrieve_collected_errors():
+  """Wraps RetrieveCollectedErrors with lazy loader."""
+  return _pywrap_toco_api.RetrieveCollectedErrors()
+
+
+def wrapped_flat_buffer_file_to_mlir(model, input_is_filepath):
+  """Wraps FlatBufferFileToMlir with lazy loader."""
+  return _pywrap_toco_api.FlatBufferToMlir(model, input_is_filepath)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/logging/gen_html.py

@@ -0,0 +1,265 @@
+# 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.
+# ==============================================================================
+"""A utility class to generate the report HTML based on a common template."""
+
+import io
+import os
+
+from tensorflow.lite.toco.logging import toco_conversion_log_pb2 as _toco_conversion_log_pb2
+from tensorflow.python.lib.io import file_io as _file_io
+from tensorflow.python.platform import resource_loader as _resource_loader
+
+html_escape_table = {
+    "&": "&",
+    '"': """,
+    "'": "'",
+    ">": ">",
+    "<": "&lt;",
+}
+
+
+def html_escape(text):
+  return "".join(html_escape_table.get(c, c) for c in text)
+
+
+def get_input_type_from_signature(op_signature):
+  """Parses op_signature and returns a string denoting the input tensor type.
+
+  Args:
+    op_signature: a string specifying the signature of a particular operator.
+      The signature of an operator contains the input tensor's shape and type,
+      output tensor's shape and type, operator's name and its version. It has
+      the following schema:
+      INPUT:input_1_shape::input_1_type::input_2_shape::input_2_type::..
+        ::OUTPUT:output_1_shape::output_1_type::output_2_shape::output_2_type::
+        ..::NAME:operator_name ::VERSION:operator_version
+     An example of an operator signature is:
+     INPUT:[1,73,73,160]::float::[64,1,1,160]::float::[64]::float::
+     OUTPUT:[1,73,73,64]::float::NAME:Conv::VERSION:1
+
+  Returns:
+    A string denoting the input tensors' type. In the form of shape/type
+    separated
+    by comma. For example:
+    shape:[1,73,73,160],type:float,shape:[64,1,1,160],type:float,shape:[64],
+    type:float
+  """
+  start = op_signature.find(":")
+  end = op_signature.find("::OUTPUT")
+  inputs = op_signature[start + 1:end]
+  lst = inputs.split("::")
+  out_str = ""
+  for i in range(len(lst)):
+    if i % 2 == 0:
+      out_str += "shape:"
+    else:
+      out_str += "type:"
+    out_str += lst[i]
+    out_str += ","
+  return out_str[:-1]
+
+
+def get_operator_type(op_name, conversion_log):
+  if op_name in conversion_log.built_in_ops:
+    return "BUILT-IN"
+  elif op_name in conversion_log.custom_ops:
+    return "CUSTOM OP"
+  else:
+    return "SELECT OP"
+
+
+class HTMLGenerator:
+  """Utility class to generate an HTML report."""
+
+  def __init__(self, html_template_path, export_report_path):
+    """Reads the HTML template content.
+
+    Args:
+      html_template_path: A string, path to the template HTML file.
+      export_report_path: A string, path to the generated HTML report. This path
+        should point to a '.html' file with date and time in its name.
+        e.g. 2019-01-01-10:05.toco_report.html.
+
+    Raises:
+      IOError: File doesn't exist.
+    """
+    # Load the template HTML.
+    if not _file_io.file_exists(html_template_path):
+      raise IOError("File '{0}' does not exist.".format(html_template_path))
+    with _file_io.FileIO(html_template_path, "r") as f:
+      self.html_template = f.read()
+
+    _file_io.recursive_create_dir(os.path.dirname(export_report_path))
+    self.export_report_path = export_report_path
+
+  def generate(self,
+               toco_conversion_log_before,
+               toco_conversion_log_after,
+               post_training_quant_enabled,
+               dot_before,
+               dot_after,
+               toco_err_log="",
+               tflite_graph_path=""):
+    """Generates the HTML report and writes it to local directory.
+
+    This function uses the fields in `toco_conversion_log_before` and
+    `toco_conversion_log_after` to populate the HTML content. Certain markers
+    (placeholders) in the HTML template are then substituted with the fields
+    from the protos. Once finished it will write the HTML file to the specified
+    local file path.
+
+    Args:
+      toco_conversion_log_before: A `TocoConversionLog` protobuf generated
+        before the model is converted by TOCO.
+      toco_conversion_log_after: A `TocoConversionLog` protobuf generated after
+        the model is converted by TOCO.
+      post_training_quant_enabled: A boolean, whether post-training quantization
+        is enabled.
+      dot_before: A string, the dot representation of the model
+        before the conversion.
+      dot_after: A string, the dot representation of the model after
+        the conversion.
+      toco_err_log: A string, the logs emitted by TOCO during conversion. Caller
+        need to ensure that this string is properly anonymized (any kind of
+        user data should be eliminated).
+      tflite_graph_path: A string, the filepath to the converted TFLite model.
+
+    Raises:
+      RuntimeError: When error occurs while generating the template.
+    """
+    html_dict = {}
+    html_dict["<!--CONVERSION_STATUS-->"] = (
+        r'<span class="label label-danger">Fail</span>'
+    ) if toco_err_log else r'<span class="label label-success">Success</span>'
+    html_dict["<!--TOTAL_OPS_BEFORE_CONVERT-->"] = str(
+        toco_conversion_log_before.model_size)
+    html_dict["<!--TOTAL_OPS_AFTER_CONVERT-->"] = str(
+        toco_conversion_log_after.model_size)
+    html_dict["<!--BUILT_IN_OPS_COUNT-->"] = str(
+        sum(toco_conversion_log_after.built_in_ops.values()))
+    html_dict["<!--SELECT_OPS_COUNT-->"] = str(
+        sum(toco_conversion_log_after.select_ops.values()))
+    html_dict["<!--CUSTOM_OPS_COUNT-->"] = str(
+        sum(toco_conversion_log_after.custom_ops.values()))
+    html_dict["<!--POST_TRAINING_QUANT_ENABLED-->"] = (
+        "is" if post_training_quant_enabled else "isn't")
+
+    pre_op_profile = ""
+    post_op_profile = ""
+
+    # Generate pre-conversion op profiles as a list of HTML table rows.
+    for i in range(len(toco_conversion_log_before.op_list)):
+      # Append operator name column.
+      pre_op_profile += "<tr><td>" + toco_conversion_log_before.op_list[
+          i] + "</td>"
+      # Append input type column.
+      if i < len(toco_conversion_log_before.op_signatures):
+        pre_op_profile += "<td>" + get_input_type_from_signature(
+            toco_conversion_log_before.op_signatures[i]) + "</td></tr>"
+      else:
+        pre_op_profile += "<td></td></tr>"
+
+    # Generate post-conversion op profiles as a list of HTML table rows.
+    for op in toco_conversion_log_after.op_list:
+      supported_type = get_operator_type(op, toco_conversion_log_after)
+      post_op_profile += ("<tr><td>" + op + "</td><td>" + supported_type +
+                          "</td></tr>")
+
+    html_dict["<!--REPEAT_TABLE1_ROWS-->"] = pre_op_profile
+    html_dict["<!--REPEAT_TABLE2_ROWS-->"] = post_op_profile
+    html_dict["<!--DOT_BEFORE_CONVERT-->"] = dot_before
+    html_dict["<!--DOT_AFTER_CONVERT-->"] = dot_after
+    if toco_err_log:
+      html_dict["<!--TOCO_INFO_LOG-->"] = html_escape(toco_err_log)
+    else:
+      success_info = ("TFLite graph conversion successful. You can preview the "
+                      "converted model at: ") + tflite_graph_path
+      html_dict["<!--TOCO_INFO_LOG-->"] = html_escape(success_info)
+
+    # Replace each marker (as keys of html_dict) with the actual text (as values
+    # of html_dict) in the HTML template string.
+    template = self.html_template
+    for marker in html_dict:
+      template = template.replace(marker, html_dict[marker], 1)
+      # Check that the marker text is replaced.
+      if template.find(marker) != -1:
+        raise RuntimeError("Could not populate marker text %r" % marker)
+
+    with _file_io.FileIO(self.export_report_path, "w") as f:
+      f.write(template)
+
+
+def gen_conversion_log_html(conversion_log_dir, quantization_enabled,
+                            tflite_graph_path):
+  """Generates an HTML report about the conversion process.
+
+  Args:
+    conversion_log_dir: A string specifying the file directory of the conversion
+      logs. It's required that before calling this function, the
+      `conversion_log_dir`
+      already contains the following files: `toco_log_before.pb`,
+        `toco_log_after.pb`, `toco_tf_graph.dot`,
+        `toco_tflite_graph.dot`.
+    quantization_enabled: A boolean, passed from the tflite converter to
+      indicate whether post-training quantization is enabled during conversion.
+    tflite_graph_path: A string, the filepath to the converted TFLite model.
+
+  Raises:
+    IOError: When any of the required files doesn't exist.
+  """
+  template_filename = _resource_loader.get_path_to_datafile("template.html")
+  if not os.path.exists(template_filename):
+    raise IOError("Failed to generate HTML: file '{0}' doesn't exist.".format(
+        template_filename))
+
+  toco_log_before_path = os.path.join(conversion_log_dir, "toco_log_before.pb")
+  toco_log_after_path = os.path.join(conversion_log_dir, "toco_log_after.pb")
+  dot_before_path = os.path.join(conversion_log_dir, "toco_tf_graph.dot")
+  dot_after_path = os.path.join(conversion_log_dir, "toco_tflite_graph.dot")
+  if not os.path.exists(toco_log_before_path):
+    raise IOError("Failed to generate HTML: file '{0}' doesn't exist.".format(
+        toco_log_before_path))
+  if not os.path.exists(toco_log_after_path):
+    raise IOError("Failed to generate HTML: file '{0}' doesn't exist.".format(
+        toco_log_after_path))
+  if not os.path.exists(dot_before_path):
+    raise IOError("Failed to generate HTML: file '{0}' doesn't exist.".format(
+        dot_before_path))
+  if not os.path.exists(dot_after_path):
+    raise IOError("Failed to generate HTML: file '{0}' doesn't exist.".format(
+        dot_after_path))
+
+  html_generator = HTMLGenerator(
+      template_filename,
+      os.path.join(conversion_log_dir, "toco_conversion_summary.html"))
+
+  # Parse the generated `TocoConversionLog`.
+  toco_conversion_log_before = _toco_conversion_log_pb2.TocoConversionLog()
+  toco_conversion_log_after = _toco_conversion_log_pb2.TocoConversionLog()
+  with open(toco_log_before_path, "rb") as f:
+    toco_conversion_log_before.ParseFromString(f.read())
+  with open(toco_log_after_path, "rb") as f:
+    toco_conversion_log_after.ParseFromString(f.read())
+
+  # Read the dot file before/after the conversion.
+  with io.open(dot_before_path, "r", encoding="utf-8") as f:
+    dot_before = f.read().rstrip()
+  with io.open(dot_after_path, "r", encoding="utf-8") as f:
+    dot_after = f.read().rstrip()
+
+  html_generator.generate(toco_conversion_log_before, toco_conversion_log_after,
+                          quantization_enabled, dot_before, dot_after,
+                          toco_conversion_log_after.toco_err_logs,
+                          tflite_graph_path)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/logging/toco_conversion_log_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/toco/logging/toco_conversion_log.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n6tensorflow/lite/toco/logging/toco_conversion_log.proto\x12\x04toco\"\xc9\x04\n\x11TocoConversionLog\x12\x0f\n\x07op_list\x18\x01 \x03(\t\x12=\n\x0c\x62uilt_in_ops\x18\x02 \x03(\x0b\x32\'.toco.TocoConversionLog.BuiltInOpsEntry\x12:\n\ncustom_ops\x18\x03 \x03(\x0b\x32&.toco.TocoConversionLog.CustomOpsEntry\x12:\n\nselect_ops\x18\x04 \x03(\x0b\x32&.toco.TocoConversionLog.SelectOpsEntry\x12\x15\n\rop_signatures\x18\x05 \x03(\t\x12\x1a\n\x12input_tensor_types\x18\x06 \x03(\t\x12\x1b\n\x13output_tensor_types\x18\x07 \x03(\t\x12\x19\n\x11log_generation_ts\x18\x08 \x01(\x03\x12\x12\n\nmodel_size\x18\t \x01(\x05\x12\x17\n\x0ftf_lite_version\x18\n \x01(\t\x12\x12\n\nos_version\x18\x0b \x01(\t\x12\x12\n\nmodel_hash\x18\x0c \x01(\t\x12\x15\n\rtoco_err_logs\x18\r \x01(\t\x1a\x31\n\x0f\x42uiltInOpsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0e\x43ustomOpsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eSelectOpsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.toco.logging.toco_conversion_log_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _TOCOCONVERSIONLOG_BUILTINOPSENTRY._options = None
+  _TOCOCONVERSIONLOG_BUILTINOPSENTRY._serialized_options = b'8\001'
+  _TOCOCONVERSIONLOG_CUSTOMOPSENTRY._options = None
+  _TOCOCONVERSIONLOG_CUSTOMOPSENTRY._serialized_options = b'8\001'
+  _TOCOCONVERSIONLOG_SELECTOPSENTRY._options = None
+  _TOCOCONVERSIONLOG_SELECTOPSENTRY._serialized_options = b'8\001'
+  _TOCOCONVERSIONLOG._serialized_start=65
+  _TOCOCONVERSIONLOG._serialized_end=650
+  _TOCOCONVERSIONLOG_BUILTINOPSENTRY._serialized_start=501
+  _TOCOCONVERSIONLOG_BUILTINOPSENTRY._serialized_end=550
+  _TOCOCONVERSIONLOG_CUSTOMOPSENTRY._serialized_start=552
+  _TOCOCONVERSIONLOG_CUSTOMOPSENTRY._serialized_end=600
+  _TOCOCONVERSIONLOG_SELECTOPSENTRY._serialized_start=602
+  _TOCOCONVERSIONLOG_SELECTOPSENTRY._serialized_end=650
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/model_flags_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/toco/model_flags.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.lite.toco import types_pb2 as tensorflow_dot_lite_dot_toco_dot_types__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&tensorflow/lite/toco/model_flags.proto\x12\x04toco\x1a tensorflow/lite/toco/types.proto\"5\n\x0fInputArrayShape\x12\x0c\n\x04\x64ims\x18\x02 \x03(\x05\x12\x14\n\x0cunknown_rank\x18\x03 \x01(\x08\"\x8f\x01\n\nInputArray\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05shape\x18\x06 \x01(\x0b\x32\x15.toco.InputArrayShape\x12\x12\n\nmean_value\x18\x03 \x01(\x02\x12\x14\n\tstd_value\x18\x04 \x01(\x02:\x01\x31\x12#\n\tdata_type\x18\x05 \x01(\x0e\x32\x10.toco.IODataType\"t\n\x08RnnState\x12\x13\n\x0bstate_array\x18\x01 \x01(\t\x12\x1e\n\x16\x62\x61\x63k_edge_source_array\x18\x02 \x01(\t\x12\x13\n\x0b\x64iscardable\x18\x05 \x01(\x08\x12\x0c\n\x04size\x18\x03 \x01(\x05\x12\x10\n\x08num_dims\x18\x04 \x01(\x05\"\xef\x01\n\x0f\x41rraysExtraInfo\x12,\n\x07\x65ntries\x18\x01 \x03(\x0b\x32\x1b.toco.ArraysExtraInfo.Entry\x1a\xad\x01\n\x05\x45ntry\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0bname_regexp\x18\x07 \x01(\t\x12\x0b\n\x03min\x18\x02 \x01(\x01\x12\x0b\n\x03max\x18\x03 \x01(\x01\x12#\n\tdata_type\x18\x04 \x01(\x0e\x32\x10.toco.IODataType\x12$\n\x05shape\x18\x05 \x01(\x0b\x32\x15.toco.InputArrayShape\x12\x1c\n\x14\x63onstant_float_value\x18\x06 \x01(\x02\"\xc6\x05\n\nModelFlags\x12&\n\x0cinput_arrays\x18\x01 \x03(\x0b\x32\x10.toco.InputArray\x12\x15\n\routput_arrays\x18\x02 \x03(\t\x12\x1d\n\x15\x63ontrol_output_arrays\x18\x18 \x03(\t\x12\x16\n\x0evariable_batch\x18\n \x01(\x08\x12\"\n\nrnn_states\x18\x0c \x03(\x0b\x32\x0e.toco.RnnState\x12\x31\n\x0cmodel_checks\x18\x0e \x03(\x0b\x32\x1b.toco.ModelFlags.ModelCheck\x12 \n\x18\x61llow_nonexistent_arrays\x18\x10 \x01(\x08\x12\x1d\n\x15\x61llow_nonascii_arrays\x18\x11 \x01(\x08\x12\x30\n\x11\x61rrays_extra_info\x18\x12 \x01(\x0b\x32\x15.toco.ArraysExtraInfo\x12(\n\x1a\x63hange_concat_input_ranges\x18\x13 \x01(\x08:\x04true\x12\x17\n\x0fsaved_model_dir\x18\x14 \x01(\t\x12\x1b\n\x13saved_model_version\x18\x15 \x01(\x05\x12\x18\n\x10saved_model_tags\x18\x16 \x03(\t\x12\"\n\x1asaved_model_exported_names\x18\x17 \x03(\t\x12\x16\n\x0euse_hlo_import\x18\x19 \x01(\x08\x12\x33\n\rhlo_file_type\x18\x1a \x01(\x0e\x32\x1c.toco.ModelFlags.HloFileType\x1aT\n\nModelCheck\x12\x18\n\ncount_type\x18\x01 \x01(\t:\x04None\x12\x15\n\tcount_min\x18\x02 \x01(\x05:\x02-1\x12\x15\n\tcount_max\x18\x03 \x01(\x05:\x02-1\"7\n\x0bHloFileType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0c\n\x08HLO_TEXT\x10\x01\x12\r\n\tHLO_PROTO\x10\x02')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.toco.model_flags_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _INPUTARRAYSHAPE._serialized_start=82
+  _INPUTARRAYSHAPE._serialized_end=135
+  _INPUTARRAY._serialized_start=138
+  _INPUTARRAY._serialized_end=281
+  _RNNSTATE._serialized_start=283
+  _RNNSTATE._serialized_end=399
+  _ARRAYSEXTRAINFO._serialized_start=402
+  _ARRAYSEXTRAINFO._serialized_end=641
+  _ARRAYSEXTRAINFO_ENTRY._serialized_start=468
+  _ARRAYSEXTRAINFO_ENTRY._serialized_end=641
+  _MODELFLAGS._serialized_start=644
+  _MODELFLAGS._serialized_end=1354
+  _MODELFLAGS_MODELCHECK._serialized_start=1213
+  _MODELFLAGS_MODELCHECK._serialized_end=1297
+  _MODELFLAGS_HLOFILETYPE._serialized_start=1299
+  _MODELFLAGS_HLOFILETYPE._serialized_end=1354
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/python/toco_from_protos.py

@@ -0,0 +1,93 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python console command to invoke TOCO from serialized protos."""
+import argparse
+import sys
+
+# We need to import pywrap_tensorflow prior to the toco wrapper.
+# pylint: disable=invalid-import-order,g-bad-import-order
+from tensorflow.python import pywrap_tensorflow  # pylint: disable=unused-import
+from tensorflow.python import _pywrap_toco_api
+from absl import app
+
+FLAGS = None
+
+
+def execute(unused_args):
+  """Runs the converter."""
+  with open(FLAGS.model_proto_file, "rb") as model_file:
+    model_str = model_file.read()
+
+  with open(FLAGS.toco_proto_file, "rb") as toco_file:
+    toco_str = toco_file.read()
+
+  with open(FLAGS.model_input_file, "rb") as input_file:
+    input_str = input_file.read()
+
+  debug_info_str = None
+  if FLAGS.debug_proto_file:
+    with open(FLAGS.debug_proto_file, "rb") as debug_info_file:
+      debug_info_str = debug_info_file.read()
+
+  enable_mlir_converter = FLAGS.enable_mlir_converter
+
+  output_str = _pywrap_toco_api.TocoConvert(
+      model_str,
+      toco_str,
+      input_str,
+      False,  # extended_return
+      debug_info_str,
+      enable_mlir_converter)
+  open(FLAGS.model_output_file, "wb").write(output_str)
+  sys.exit(0)
+
+
+def main():
+  global FLAGS
+  parser = argparse.ArgumentParser(
+      description="Invoke toco using protos as input.")
+  parser.add_argument(
+      "model_proto_file",
+      type=str,
+      help="File containing serialized proto that describes the model.")
+  parser.add_argument(
+      "toco_proto_file",
+      type=str,
+      help="File containing serialized proto describing how TOCO should run.")
+  parser.add_argument(
+      "model_input_file", type=str, help="Input model is read from this file.")
+  parser.add_argument(
+      "model_output_file",
+      type=str,
+      help="Result of applying TOCO conversion is written here.")
+  parser.add_argument(
+      "--debug_proto_file",
+      type=str,
+      default="",
+      help=("File containing serialized `GraphDebugInfo` proto that describes "
+            "logging information."))
+  parser.add_argument(
+      "--enable_mlir_converter",
+      action="store_true",
+      help=("Boolean indicating whether to enable MLIR-based conversion "
+            "instead of TOCO conversion. (default False)"))
+
+  FLAGS, unparsed = parser.parse_known_args()
+
+  app.run(main=execute, argv=[sys.argv[0]] + unparsed)
+
+
+if __name__ == "__main__":
+  main()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/toco_flags_pb2.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/toco/toco_flags.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.compiler.mlir.lite.debug import debug_options_pb2 as tensorflow_dot_compiler_dot_mlir_dot_lite_dot_debug_dot_debug__options__pb2
+from tensorflow.compiler.mlir.quantization.stablehlo import quantization_options_pb2 as tensorflow_dot_compiler_dot_mlir_dot_quantization_dot_stablehlo_dot_quantization__options__pb2
+from tensorflow.lite.toco import types_pb2 as tensorflow_dot_lite_dot_toco_dot_types__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%tensorflow/lite/toco/toco_flags.proto\x12\x04toco\x1a\x37tensorflow/compiler/mlir/lite/debug/debug_options.proto\x1aJtensorflow/compiler/mlir/quantization/stablehlo/quantization_options.proto\x1a tensorflow/lite/toco/types.proto\"\xdc\x10\n\tTocoFlags\x12&\n\x0cinput_format\x18\x01 \x01(\x0e\x32\x10.toco.FileFormat\x12\'\n\routput_format\x18\x02 \x01(\x0e\x32\x10.toco.FileFormat\x12.\n\x14inference_input_type\x18\x0b \x01(\x0e\x32\x10.toco.IODataType\x12(\n\x0einference_type\x18\x04 \x01(\x0e\x32\x10.toco.IODataType\x12\x1a\n\x12\x64\x65\x66\x61ult_ranges_min\x18\x05 \x01(\x02\x12\x1a\n\x12\x64\x65\x66\x61ult_ranges_max\x18\x06 \x01(\x02\x12 \n\x18\x64\x65\x66\x61ult_int16_ranges_min\x18\x0f \x01(\x02\x12 \n\x18\x64\x65\x66\x61ult_int16_ranges_max\x18\x10 \x01(\x02\x12\x17\n\x0f\x64rop_fake_quant\x18\x07 \x01(\x08\x12!\n\x19reorder_across_fake_quant\x18\x08 \x01(\x08\x12\x18\n\x10\x61llow_custom_ops\x18\n \x01(\x08\x12\x1f\n\x17\x64rop_control_dependency\x18\x0c \x01(\x08\x12+\n#debug_disable_recurrent_cell_fusion\x18\r \x01(\x08\x12%\n\x1dpropagate_fake_quant_num_bits\x18\x0e \x01(\x08\x12\x35\n-allow_nudging_weights_to_use_fast_gemm_kernel\x18\x11 \x01(\x08\x12\'\n\x1b\x64\x65\x64upe_array_min_size_bytes\x18\x12 \x01(\x03:\x02\x36\x34\x12&\n\x18split_tflite_lstm_inputs\x18\x13 \x01(\x08:\x04true\x12\x1f\n\x10quantize_weights\x18\x14 \x01(\x08:\x05\x66\x61lse\x12\x19\n\x11\x64ump_graphviz_dir\x18\x18 \x01(\t\x12#\n\x1b\x64ump_graphviz_include_video\x18\x19 \x01(\x08\x12%\n\x16post_training_quantize\x18\x1a \x01(\x08:\x05\x66\x61lse\x12#\n\x14\x65nable_select_tf_ops\x18\x1b \x01(\x08:\x05\x66\x61lse\x12\"\n\x13\x66orce_select_tf_ops\x18\x1c \x01(\x08:\x05\x66\x61lse\x12\"\n\x13quantize_to_float16\x18\x1d \x01(\x08:\x05\x66\x61lse\x12#\n\x15\x61llow_dynamic_tensors\x18\x1e \x01(\x08:\x04true\x12\x1e\n\x16\x63onversion_summary_dir\x18\x1f \x01(\t\x12\x19\n\rcustom_opdefs\x18  \x03(\tB\x02\x18\x01\x12\x1a\n\x12select_user_tf_ops\x18! \x03(\t\x12.\n enable_tflite_resource_variables\x18\" \x01(\x08:\x04true\x12!\n\x12unfold_batchmatmul\x18# \x01(\x08:\x05\x66\x61lse\x12#\n\x15lower_tensor_list_ops\x18$ \x01(\x08:\x04true\x12+\n\x11\x61\x63\x63umulation_type\x18% \x01(\x0e\x32\x10.toco.IODataType\x12\x1d\n\x0e\x61llow_bfloat16\x18& \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x17\x61llow_all_select_tf_ops\x18\' \x01(\x08\x12*\n\x1bunfold_large_splat_constant\x18( \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x12supported_backends\x18) \x03(\t\x12\x39\n*default_to_single_batch_in_tensor_list_ops\x18* \x01(\x08:\x05\x66\x61lse\x12/\n disable_per_channel_quantization\x18+ \x01(\x08:\x05\x66\x61lse\x12\x32\n#enable_mlir_dynamic_range_quantizer\x18, \x01(\x08:\x05\x66\x61lse\x12\x1c\n\x14tf_quantization_mode\x18- \x01(\t\x12)\n\x1a\x64isable_infer_tensor_range\x18. \x01(\x08:\x05\x66\x61lse\x12&\n\x17use_fake_quant_num_bits\x18/ \x01(\x08:\x05\x66\x61lse\x12*\n\x1b\x65nable_dynamic_update_slice\x18\x30 \x01(\x08:\x05\x66\x61lse\x12!\n\x12preserve_assert_op\x18\x31 \x01(\x08:\x05\x66\x61lse\x12*\n\x1bguarantee_all_funcs_one_use\x18\x32 \x01(\x08:\x05\x66\x61lse\x12#\n\x14\x63onvert_to_stablehlo\x18\x33 \x01(\x08:\x05\x66\x61lse\x12\x30\n!enable_mlir_variable_quantization\x18\x34 \x01(\x08:\x05\x66\x61lse\x12&\n\x17\x64isable_fuse_mul_and_fc\x18\x35 \x01(\x08:\x05\x66\x61lse\x12I\n\x14quantization_options\x18\x36 \x01(\x0b\x32+.stablehlo.quantization.QuantizationOptions\x12.\n\x1b\x65nable_hlo_to_tf_conversion\x18\x37 \x01(\x08:\x05\x66\x61lseB\x02\x18\x01\x12\x39\n\rdebug_options\x18\x38 \x01(\x0b\x32\".tensorflow.converter.DebugOptions\x12 \n\x11use_buffer_offset\x18\x39 \x01(\x08:\x05\x66\x61lse\x12.\n\x1flegalize_custom_tensor_list_ops\x18: \x01(\x08:\x05\x66\x61lse\x12$\n\x15reduce_type_precision\x18; \x01(\x08:\x05\x66\x61lse*\\\n\nFileFormat\x12\x17\n\x13\x46ILE_FORMAT_UNKNOWN\x10\x00\x12\x17\n\x13TENSORFLOW_GRAPHDEF\x10\x01\x12\n\n\x06TFLITE\x10\x02\x12\x10\n\x0cGRAPHVIZ_DOT\x10\x03')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.toco.toco_flags_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _TOCOFLAGS.fields_by_name['custom_opdefs']._options = None
+  _TOCOFLAGS.fields_by_name['custom_opdefs']._serialized_options = b'\030\001'
+  _TOCOFLAGS.fields_by_name['enable_hlo_to_tf_conversion']._options = None
+  _TOCOFLAGS.fields_by_name['enable_hlo_to_tf_conversion']._serialized_options = b'\030\001'
+  _FILEFORMAT._serialized_start=2357
+  _FILEFORMAT._serialized_end=2449
+  _TOCOFLAGS._serialized_start=215
+  _TOCOFLAGS._serialized_end=2355
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/toco/types_pb2.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/toco/types.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n tensorflow/lite/toco/types.proto\x12\x04toco*\xb3\x02\n\nIODataType\x12\x18\n\x14IO_DATA_TYPE_UNKNOWN\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\x13\n\x0fQUANTIZED_UINT8\x10\x02\x12\t\n\x05INT32\x10\x03\x12\t\n\x05INT64\x10\x04\x12\n\n\x06STRING\x10\x05\x12\x13\n\x0fQUANTIZED_INT16\x10\x06\x12\x08\n\x04\x42OOL\x10\x07\x12\r\n\tCOMPLEX64\x10\x08\x12\x12\n\x0eQUANTIZED_INT8\x10\t\x12\x0b\n\x07\x46LOAT16\x10\n\x12\x0b\n\x07\x46LOAT64\x10\x0b\x12\x0e\n\nCOMPLEX128\x10\x0c\x12\n\n\x06UINT64\x10\r\x12\x0c\n\x08RESOURCE\x10\x0e\x12\x0b\n\x07VARIANT\x10\x0f\x12\n\n\x06UINT32\x10\x10\x12\t\n\x05UINT8\x10\x11\x12\x08\n\x04INT8\x10\x12\x12\t\n\x05INT16\x10\x13\x12\n\n\x06UINT16\x10\x14')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.toco.types_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _IODATATYPE._serialized_start=43
+  _IODATATYPE._serialized_end=350
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/lite/tools/flatbuffer_utils.py

@@ -0,0 +1,432 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utility functions for FlatBuffers.
+
+All functions that are commonly used to work with FlatBuffers.
+
+Refer to the tensorflow lite flatbuffer schema here:
+tensorflow/lite/schema/schema.fbs
+"""
+
+import copy
+import random
+import re
+import struct
+import sys
+
+import flatbuffers
+
+from tensorflow.lite.python import schema_py_generated as schema_fb
+from tensorflow.lite.python import schema_util
+from tensorflow.python.platform import gfile
+
+_TFLITE_FILE_IDENTIFIER = b'TFL3'
+
+
+def convert_bytearray_to_object(model_bytearray):
+  """Converts a tflite model from a bytearray to an object for parsing."""
+  model_object = schema_fb.Model.GetRootAsModel(model_bytearray, 0)
+  return schema_fb.ModelT.InitFromObj(model_object)
+
+
+def read_model(input_tflite_file):
+  """Reads a tflite model as a python object.
+
+  Args:
+    input_tflite_file: Full path name to the input tflite file
+
+  Raises:
+    RuntimeError: If input_tflite_file path is invalid.
+    IOError: If input_tflite_file cannot be opened.
+
+  Returns:
+    A python object corresponding to the input tflite file.
+  """
+  if not gfile.Exists(input_tflite_file):
+    raise RuntimeError('Input file not found at %r\n' % input_tflite_file)
+  with gfile.GFile(input_tflite_file, 'rb') as input_file_handle:
+    model_bytearray = bytearray(input_file_handle.read())
+  model = convert_bytearray_to_object(model_bytearray)
+  if sys.byteorder == 'big':
+    byte_swap_tflite_model_obj(model, 'little', 'big')
+  return model
+
+
+def read_model_with_mutable_tensors(input_tflite_file):
+  """Reads a tflite model as a python object with mutable tensors.
+
+  Similar to read_model() with the addition that the returned object has
+  mutable tensors (read_model() returns an object with immutable tensors).
+
+  NOTE: This API only works for TFLite generated with
+  _experimental_use_buffer_offset=false
+
+  Args:
+    input_tflite_file: Full path name to the input tflite file
+
+  Raises:
+    RuntimeError: If input_tflite_file path is invalid.
+    IOError: If input_tflite_file cannot be opened.
+
+  Returns:
+    A mutable python object corresponding to the input tflite file.
+  """
+  return copy.deepcopy(read_model(input_tflite_file))
+
+
+def convert_object_to_bytearray(model_object, extra_buffer=b''):
+  """Converts a tflite model from an object to a immutable bytearray."""
+  # Initial size of the buffer, which will grow automatically if needed
+  builder = flatbuffers.Builder(1024)
+  model_offset = model_object.Pack(builder)
+  builder.Finish(model_offset, file_identifier=_TFLITE_FILE_IDENTIFIER)
+  model_bytearray = bytes(builder.Output())
+  model_bytearray = model_bytearray + extra_buffer
+  return model_bytearray
+
+
+def write_model(model_object, output_tflite_file):
+  """Writes the tflite model, a python object, into the output file.
+
+  NOTE: This API only works for TFLite generated with
+  _experimental_use_buffer_offset=false
+
+  Args:
+    model_object: A tflite model as a python object
+    output_tflite_file: Full path name to the output tflite file.
+
+  Raises:
+    IOError: If output_tflite_file path is invalid or cannot be opened.
+  """
+  if sys.byteorder == 'big':
+    model_object = copy.deepcopy(model_object)
+    byte_swap_tflite_model_obj(model_object, 'big', 'little')
+  model_bytearray = convert_object_to_bytearray(model_object)
+  with gfile.GFile(output_tflite_file, 'wb') as output_file_handle:
+    output_file_handle.write(model_bytearray)
+
+
+def strip_strings(model):
+  """Strips all nonessential strings from the model to reduce model size.
+
+  We remove the following strings:
+  (find strings by searching ":string" in the tensorflow lite flatbuffer schema)
+  1. Model description
+  2. SubGraph name
+  3. Tensor names
+  We retain OperatorCode custom_code and Metadata name.
+
+  Args:
+    model: The model from which to remove nonessential strings.
+  """
+
+  model.description = None
+  for subgraph in model.subgraphs:
+    subgraph.name = None
+    for tensor in subgraph.tensors:
+      tensor.name = None
+  # We clear all signature_def structure, since without names it is useless.
+  model.signatureDefs = None
+
+
+def type_to_name(tensor_type):
+  """Converts a numerical enum to a readable tensor type."""
+  for name, value in schema_fb.TensorType.__dict__.items():
+    if value == tensor_type:
+      return name
+  return None
+
+
+def randomize_weights(model, random_seed=0, buffers_to_skip=None):
+  """Randomize weights in a model.
+
+  Args:
+    model: The model in which to randomize weights.
+    random_seed: The input to the random number generator (default value is 0).
+    buffers_to_skip: The list of buffer indices to skip. The weights in these
+      buffers are left unmodified.
+  """
+
+  # The input to the random seed generator. The default value is 0.
+  random.seed(random_seed)
+
+  # Parse model buffers which store the model weights
+  buffers = model.buffers
+  buffer_ids = range(1, len(buffers))  # ignore index 0 as it's always None
+  if buffers_to_skip is not None:
+    buffer_ids = [idx for idx in buffer_ids if idx not in buffers_to_skip]
+
+  buffer_types = {}
+  for graph in model.subgraphs:
+    for op in graph.operators:
+      if op.inputs is None:
+        break
+      for input_idx in op.inputs:
+        tensor = graph.tensors[input_idx]
+        buffer_types[tensor.buffer] = type_to_name(tensor.type)
+
+  for i in buffer_ids:
+    buffer_i_data = buffers[i].data
+    buffer_i_size = 0 if buffer_i_data is None else buffer_i_data.size
+    if buffer_i_size == 0:
+      continue
+
+    # Raw data buffers are of type ubyte (or uint8) whose values lie in the
+    # range [0, 255]. Those ubytes (or unint8s) are the underlying
+    # representation of each datatype. For example, a bias tensor of type
+    # int32 appears as a buffer 4 times it's length of type ubyte (or uint8).
+    # For floats, we need to generate a valid float and then pack it into
+    # the raw bytes in place.
+    buffer_type = buffer_types.get(i, 'INT8')
+    if buffer_type.startswith('FLOAT'):
+      format_code = 'e' if buffer_type == 'FLOAT16' else 'f'
+      for offset in range(0, buffer_i_size, struct.calcsize(format_code)):
+        value = random.uniform(-0.5, 0.5)  # See http://b/152324470#comment2
+        struct.pack_into(format_code, buffer_i_data, offset, value)
+    else:
+      for j in range(buffer_i_size):
+        buffer_i_data[j] = random.randint(0, 255)
+
+
+def rename_custom_ops(model, map_custom_op_renames):
+  """Rename custom ops so they use the same naming style as builtin ops.
+
+  Args:
+    model: The input tflite model.
+    map_custom_op_renames: A mapping from old to new custom op names.
+  """
+  for op_code in model.operatorCodes:
+    if op_code.customCode:
+      op_code_str = op_code.customCode.decode('ascii')
+      if op_code_str in map_custom_op_renames:
+        op_code.customCode = map_custom_op_renames[op_code_str].encode('ascii')
+
+
+def opcode_to_name(model, op_code):
+  """Converts a TFLite op_code to the human readable name.
+
+  Args:
+    model: The input tflite model.
+    op_code: The op_code to resolve to a readable name.
+
+  Returns:
+    A string containing the human readable op name, or None if not resolvable.
+  """
+  op = model.operatorCodes[op_code]
+  code = max(op.builtinCode, op.deprecatedBuiltinCode)
+  for name, value in vars(schema_fb.BuiltinOperator).items():
+    if value == code:
+      return name
+  return None
+
+
+def xxd_output_to_bytes(input_cc_file):
+  """Converts xxd output C++ source file to bytes (immutable).
+
+  Args:
+    input_cc_file: Full path name to th C++ source file dumped by xxd
+
+  Raises:
+    RuntimeError: If input_cc_file path is invalid.
+    IOError: If input_cc_file cannot be opened.
+
+  Returns:
+    A bytearray corresponding to the input cc file array.
+  """
+  # Match hex values in the string with comma as separator
+  pattern = re.compile(r'\W*(0x[0-9a-fA-F,x ]+).*')
+
+  model_bytearray = bytearray()
+
+  with open(input_cc_file) as file_handle:
+    for line in file_handle:
+      values_match = pattern.match(line)
+
+      if values_match is None:
+        continue
+
+      # Match in the parentheses (hex array only)
+      list_text = values_match.group(1)
+
+      # Extract hex values (text) from the line
+      # e.g. 0x1c, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c,
+      values_text = filter(None, list_text.split(','))
+
+      # Convert to hex
+      values = [int(x, base=16) for x in values_text]
+      model_bytearray.extend(values)
+
+  return bytes(model_bytearray)
+
+
+def xxd_output_to_object(input_cc_file):
+  """Converts xxd output C++ source file to object.
+
+  Args:
+    input_cc_file: Full path name to th C++ source file dumped by xxd
+
+  Raises:
+    RuntimeError: If input_cc_file path is invalid.
+    IOError: If input_cc_file cannot be opened.
+
+  Returns:
+    A python object corresponding to the input tflite file.
+  """
+  model_bytes = xxd_output_to_bytes(input_cc_file)
+  return convert_bytearray_to_object(model_bytes)
+
+
+def byte_swap_buffer_content(buffer, chunksize, from_endiness, to_endiness):
+  """Helper function for byte-swapping the buffers field."""
+  to_swap = [
+      buffer.data[i : i + chunksize]
+      for i in range(0, len(buffer.data), chunksize)
+  ]
+  buffer.data = b''.join(
+      [
+          int.from_bytes(byteswap, from_endiness).to_bytes(
+              chunksize, to_endiness
+          )
+          for byteswap in to_swap
+      ]
+  )
+
+
+def byte_swap_string_content(buffer, from_endiness, to_endiness):
+  """Helper function for byte-swapping the string buffer.
+
+  Args:
+    buffer: TFLite string buffer of from_endiness format.
+    from_endiness: The original endianness format of the string buffer.
+    to_endiness: The destined endianness format of the string buffer.
+  """
+  num_of_strings = int.from_bytes(buffer.data[0:4], from_endiness)
+  string_content = bytearray(buffer.data[4 * (num_of_strings + 2) :])
+  prefix_data = b''.join(
+      [
+          int.from_bytes(buffer.data[i : i + 4], from_endiness).to_bytes(
+              4, to_endiness
+          )
+          for i in range(0, (num_of_strings + 1) * 4 + 1, 4)
+      ]
+  )
+  buffer.data = prefix_data + string_content
+
+
+def byte_swap_tflite_model_obj(model, from_endiness, to_endiness):
+  """Byte swaps the buffers field in a TFLite model.
+
+  Args:
+    model: TFLite model object of from_endiness format.
+    from_endiness: The original endianness format of the buffers in model.
+    to_endiness: The destined endianness format of the buffers in model.
+  """
+  if model is None:
+    return
+  # Get all the constant buffers, byte swapping them as per their data types
+  buffer_swapped = []
+  types_of_16_bits = [
+      schema_fb.TensorType.FLOAT16,
+      schema_fb.TensorType.INT16,
+      schema_fb.TensorType.UINT16,
+  ]
+  types_of_32_bits = [
+      schema_fb.TensorType.FLOAT32,
+      schema_fb.TensorType.INT32,
+      schema_fb.TensorType.COMPLEX64,
+      schema_fb.TensorType.UINT32,
+  ]
+  types_of_64_bits = [
+      schema_fb.TensorType.INT64,
+      schema_fb.TensorType.FLOAT64,
+      schema_fb.TensorType.COMPLEX128,
+      schema_fb.TensorType.UINT64,
+  ]
+  for subgraph in model.subgraphs:
+    for tensor in subgraph.tensors:
+      if (
+          tensor.buffer > 0
+          and tensor.buffer < len(model.buffers)
+          and tensor.buffer not in buffer_swapped
+          and model.buffers[tensor.buffer].data is not None
+      ):
+        if tensor.type == schema_fb.TensorType.STRING:
+          byte_swap_string_content(
+              model.buffers[tensor.buffer], from_endiness, to_endiness
+          )
+        elif tensor.type in types_of_16_bits:
+          byte_swap_buffer_content(
+              model.buffers[tensor.buffer], 2, from_endiness, to_endiness
+          )
+        elif tensor.type in types_of_32_bits:
+          byte_swap_buffer_content(
+              model.buffers[tensor.buffer], 4, from_endiness, to_endiness
+          )
+        elif tensor.type in types_of_64_bits:
+          byte_swap_buffer_content(
+              model.buffers[tensor.buffer], 8, from_endiness, to_endiness
+          )
+        else:
+          continue
+        buffer_swapped.append(tensor.buffer)
+
+
+def byte_swap_tflite_buffer(tflite_model, from_endiness, to_endiness):
+  """Generates a new model byte array after byte swapping its buffers field.
+
+  Args:
+    tflite_model: TFLite flatbuffer in a byte array.
+    from_endiness: The original endianness format of the buffers in
+      tflite_model.
+    to_endiness: The destined endianness format of the buffers in tflite_model.
+
+  Returns:
+    TFLite flatbuffer in a byte array, after being byte swapped to to_endiness
+    format.
+  """
+  if tflite_model is None:
+    return None
+  # Load TFLite Flatbuffer byte array into an object.
+  model = convert_bytearray_to_object(tflite_model)
+
+  # Byte swapping the constant buffers as per their data types
+  byte_swap_tflite_model_obj(model, from_endiness, to_endiness)
+
+  # Return a TFLite flatbuffer as a byte array.
+  return convert_object_to_bytearray(model)
+
+
+def count_resource_variables(model):
+  """Calculates the number of unique resource variables in a model.
+
+  Args:
+    model: the input tflite model, either as bytearray or object.
+
+  Returns:
+    An integer number representing the number of unique resource variables.
+  """
+  if not isinstance(model, schema_fb.ModelT):
+    model = convert_bytearray_to_object(model)
+  unique_shared_names = set()
+  for subgraph in model.subgraphs:
+    if subgraph.operators is None:
+      continue
+    for op in subgraph.operators:
+      builtin_code = schema_util.get_builtin_code_from_operator_code(
+          model.operatorCodes[op.opcodeIndex]
+      )
+      if builtin_code == schema_fb.BuiltinOperator.VAR_HANDLE:
+        unique_shared_names.add(op.builtinOptions.sharedName)
+  return len(unique_shared_names)