Add files using upload-large-folder tool

.gitattributes

@@ -198,3 +198,8 @@ SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/gr
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/profiler/internal/_pywrap_profiler.so filter=lfs diff=lfs merge=lfs -text
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so filter=lfs diff=lfs merge=lfs -text
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/impl/testing/pybind_for_testing.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/interpreter_wrapper/_pywrap_tensorflow_interpreter_wrapper.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/optimize/_pywrap_tensorflow_lite_calibration_wrapper.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/metrics/_pywrap_tensorflow_lite_metrics_wrapper.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/analyzer_wrapper/_pywrap_analyzer_wrapper.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/experimental/microfrontend/python/ops/_audio_microfrontend_op.so filter=lfs diff=lfs merge=lfs -text

SwarmUI/dlbackend/ComfyUI/venv/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
+

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/experimental/microfrontend/python/ops/_audio_microfrontend_op.so

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

SwarmUI/dlbackend/ComfyUI/venv/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")

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/profiling/proto/model_runtime_info_pb2.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/profiling/proto/model_runtime_info.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.profiling.proto import profiling_info_pb2 as tensorflow_dot_lite_dot_profiling_dot_proto_dot_profiling__info__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n8tensorflow/lite/profiling/proto/model_runtime_info.proto\x12\x10tflite.profiling\x1a\x34tensorflow/lite/profiling/proto/profiling_info.proto\"_\n\x13ModelRuntimeDetails\x12\x12\n\nmodel_name\x18\x01 \x01(\t\x12\x34\n\tsubgraphs\x18\x02 \x03(\x0b\x32!.tflite.profiling.RuntimeSubgraph\"\xa9\x02\n\x0fRuntimeSubgraph\x12\x13\n\x0bsubgraph_id\x18\x01 \x01(\x05\x12%\n\x05\x65\x64ges\x18\x02 \x03(\x0b\x32\x16.tflite.profiling.Edge\x12%\n\x05nodes\x18\x03 \x03(\x0b\x32\x16.tflite.profiling.Node\x12\x1a\n\x0e\x65xecution_plan\x18\x04 \x03(\x05\x42\x02\x10\x01\x12\x45\n\rsubgraph_type\x18\x05 \x01(\x0e\x32..tflite.profiling.RuntimeSubgraph.SubgraphType\"P\n\x0cSubgraphType\x12\x14\n\x10UNKNOWN_SUBGRAPH\x10\x00\x12\x13\n\x0fTFLITE_SUBGRAPH\x10\x01\x12\x15\n\x11\x44\x45LEGATE_SUBGRAPH\x10\x02\"\xba\x02\n\x04Node\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x0c\n\x04type\x18\x03 \x01(\t\x12\x12\n\x06inputs\x18\x04 \x03(\x05\x42\x02\x10\x01\x12\x13\n\x07outputs\x18\x05 \x03(\x05\x42\x02\x10\x01\x12\x19\n\rintermediates\x18\x06 \x03(\x05\x42\x02\x10\x01\x12\x17\n\x0btemporaries\x18\x07 \x03(\x05\x42\x02\x10\x01\x12\x38\n\x0fop_profile_data\x18\n \x01(\x0b\x32\x1f.tflite.profiling.OpProfileData\x12\x46\n\x15\x64\x65legate_node_details\x18\x08 \x01(\x0b\x32%.tflite.profiling.DelegateNodeDetailsH\x00\x12\x1e\n\x14\x64\x65legated_to_node_id\x18\t \x01(\x05H\x00\x42\x0b\n\tnode_info\"R\n\x13\x44\x65legateNodeDetails\x12\x15\n\rdelegate_name\x18\x01 \x01(\t\x12$\n\x18tflite_node_ids_replaced\x18\x02 \x03(\x05\x42\x02\x10\x01\"\x81\x05\n\x04\x45\x64ge\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x32\n\tdata_type\x18\x03 \x01(\x0e\x32\x1f.tflite.profiling.Edge.DataType\x12\x11\n\x05shape\x18\x04 \x03(\x05\x42\x02\x10\x01\x12\x17\n\x0f\x61llocation_type\x18\x05 \x01(\t\x12\x36\n\x0blayout_type\x18\x06 \x01(\x0e\x32!.tflite.profiling.Edge.LayoutType\x12\x0c\n\x04size\x18\x07 \x01(\x05\"\x85\x02\n\x08\x44\x61taType\x12\x10\n\x0cUNKNOWN_TYPE\x10\x00\x12\x0b\n\x07\x46LOAT32\x10\x01\x12\t\n\x05INT32\x10\x02\x12\t\n\x05UINT8\x10\x03\x12\t\n\x05INT64\x10\x04\x12\n\n\x06STRING\x10\x05\x12\x08\n\x04\x42OOL\x10\x06\x12\t\n\x05INT16\x10\x07\x12\r\n\tCOMPLEX64\x10\x08\x12\x08\n\x04INT8\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\n\n\x06UINT16\x10\x11\x12\x08\n\x04INT4\x10\x12\x12\x0c\n\x08\x42\x46LOAT16\x10\x13\"\xb0\x01\n\nLayoutType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\n\n\x06SCALAR\x10\x01\x12\n\n\x06LINEAR\x10\x02\x12\x06\n\x02HW\x10\x03\x12\x07\n\x03\x43HW\x10\x04\x12\x07\n\x03HWC\x10\x05\x12\x08\n\x04OIHW\x10\x06\x12\x08\n\x04OHWI\x10\x07\x12\x08\n\x04IHWO\x10\x08\x12\x08\n\x04IOHW\x10\t\x12\x08\n\x04\x42HWC\x10\n\x12\x08\n\x04HWDC\x10\x0b\x12\t\n\x05\x42HWDC\x10\x0c\x12\x07\n\x03HWD\x10\r\x12\t\n\x05OHWDI\x10\x0e\x12\x08\n\x04HWIO\x10\x0f\x42\x02P\x01')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.profiling.proto.model_runtime_info_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'P\001'
+  _RUNTIMESUBGRAPH.fields_by_name['execution_plan']._options = None
+  _RUNTIMESUBGRAPH.fields_by_name['execution_plan']._serialized_options = b'\020\001'
+  _NODE.fields_by_name['inputs']._options = None
+  _NODE.fields_by_name['inputs']._serialized_options = b'\020\001'
+  _NODE.fields_by_name['outputs']._options = None
+  _NODE.fields_by_name['outputs']._serialized_options = b'\020\001'
+  _NODE.fields_by_name['intermediates']._options = None
+  _NODE.fields_by_name['intermediates']._serialized_options = b'\020\001'
+  _NODE.fields_by_name['temporaries']._options = None
+  _NODE.fields_by_name['temporaries']._serialized_options = b'\020\001'
+  _DELEGATENODEDETAILS.fields_by_name['tflite_node_ids_replaced']._options = None
+  _DELEGATENODEDETAILS.fields_by_name['tflite_node_ids_replaced']._serialized_options = b'\020\001'
+  _EDGE.fields_by_name['shape']._options = None
+  _EDGE.fields_by_name['shape']._serialized_options = b'\020\001'
+  _MODELRUNTIMEDETAILS._serialized_start=132
+  _MODELRUNTIMEDETAILS._serialized_end=227
+  _RUNTIMESUBGRAPH._serialized_start=230
+  _RUNTIMESUBGRAPH._serialized_end=527
+  _RUNTIMESUBGRAPH_SUBGRAPHTYPE._serialized_start=447
+  _RUNTIMESUBGRAPH_SUBGRAPHTYPE._serialized_end=527
+  _NODE._serialized_start=530
+  _NODE._serialized_end=844
+  _DELEGATENODEDETAILS._serialized_start=846
+  _DELEGATENODEDETAILS._serialized_end=928
+  _EDGE._serialized_start=931
+  _EDGE._serialized_end=1572
+  _EDGE_DATATYPE._serialized_start=1132
+  _EDGE_DATATYPE._serialized_end=1393
+  _EDGE_LAYOUTTYPE._serialized_start=1396
+  _EDGE_LAYOUTTYPE._serialized_end=1572
+# @@protoc_insertion_point(module_scope)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/profiling/proto/profiling_info_pb2.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/lite/profiling/proto/profiling_info.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'\n4tensorflow/lite/profiling/proto/profiling_info.proto\x12\x10tflite.profiling\"\xa7\x01\n\x16\x42\x65nchmarkProfilingData\x12\x12\n\nmodel_name\x18\x01 \x01(\t\x12:\n\x0cinit_profile\x18\x02 \x01(\x0b\x32$.tflite.profiling.ModelProfilingData\x12=\n\x0fruntime_profile\x18\x03 \x01(\x0b\x32$.tflite.profiling.ModelProfilingData\"\x9c\x01\n\x12ModelProfilingData\x12\x42\n\x11subgraph_profiles\x18\x01 \x03(\x0b\x32\'.tflite.profiling.SubGraphProfilingData\x12\x42\n\x11\x64\x65legate_profiles\x18\x02 \x03(\x0b\x32\'.tflite.profiling.DelegateProfilingData\"\x80\x01\n\x15SubGraphProfilingData\x12\x15\n\rsubgraph_name\x18\x01 \x01(\t\x12\x16\n\x0esubgraph_index\x18\x02 \x01(\x05\x12\x38\n\x0fper_op_profiles\x18\x03 \x03(\x0b\x32\x1f.tflite.profiling.OpProfileData\"h\n\x15\x44\x65legateProfilingData\x12\x15\n\rdelegate_name\x18\x01 \x01(\t\x12\x38\n\x0fper_op_profiles\x18\x02 \x03(\x0b\x32\x1f.tflite.profiling.OpProfileData\"\x93\x01\n\x0fOpProfilingStat\x12\r\n\x05\x66irst\x18\x01 \x01(\x03\x12\x0c\n\x04last\x18\x02 \x01(\x03\x12\x0b\n\x03\x61vg\x18\x03 \x01(\x03\x12\x0e\n\x06stddev\x18\x04 \x01(\x02\x12\x10\n\x08variance\x18\x05 \x01(\x02\x12\x0b\n\x03min\x18\x06 \x01(\x03\x12\x0b\n\x03max\x18\x07 \x01(\x03\x12\x0b\n\x03sum\x18\x08 \x01(\x03\x12\r\n\x05\x63ount\x18\t \x01(\x03\"\xcf\x01\n\rOpProfileData\x12\x11\n\tnode_type\x18\x01 \x01(\t\x12\x41\n\x16inference_microseconds\x18\x02 \x01(\x0b\x32!.tflite.profiling.OpProfilingStat\x12\x31\n\x06mem_kb\x18\x03 \x01(\x0b\x32!.tflite.profiling.OpProfilingStat\x12\x14\n\x0ctimes_called\x18\x04 \x01(\x03\x12\x0c\n\x04name\x18\x05 \x01(\t\x12\x11\n\trun_order\x18\x06 \x01(\x03\x42\x02P\x01')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.lite.profiling.proto.profiling_info_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'P\001'
+  _BENCHMARKPROFILINGDATA._serialized_start=75
+  _BENCHMARKPROFILINGDATA._serialized_end=242
+  _MODELPROFILINGDATA._serialized_start=245
+  _MODELPROFILINGDATA._serialized_end=401
+  _SUBGRAPHPROFILINGDATA._serialized_start=404
+  _SUBGRAPHPROFILINGDATA._serialized_end=532
+  _DELEGATEPROFILINGDATA._serialized_start=534
+  _DELEGATEPROFILINGDATA._serialized_end=638
+  _OPPROFILINGSTAT._serialized_start=641
+  _OPPROFILINGSTAT._serialized_end=788
+  _OPPROFILEDATA._serialized_start=791
+  _OPPROFILEDATA._serialized_end=998
+# @@protoc_insertion_point(module_scope)

SwarmUI/dlbackend/ComfyUI/venv/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: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/analyzer_wrapper/_pywrap_analyzer_wrapper.so

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

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/authoring/authoring.py

@@ -0,0 +1,301 @@
+# 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
+from tensorflow.compiler.mlir.lite.metrics import converter_error_data_pb2
+# pylint: disable=g-import-not-at-top
+from tensorflow.lite.python import convert
+from tensorflow.lite.python import lite
+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)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/lite/python/convert.py

@@ -0,0 +1,1250 @@
+# 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.lite import converter_flags_pb2 as _conversion_flags_pb2
+from tensorflow.compiler.mlir.lite import model_flags_pb2 as _model_flags_pb2
+from tensorflow.compiler.mlir.lite import types_pb2 as _types_pb2
+from tensorflow.compiler.mlir.lite.metrics import converter_error_data_pb2
+from tensorflow.compiler.mlir.lite.python import wrap_converter
+from tensorflow.compiler.mlir.quantization.stablehlo import quantization_config_pb2
+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.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.wrapper import metrics_wrapper as _metrics_wrapper
+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.ConverterFlags,
+) -> 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 compiler/mlir/lite/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 compiler/mlir/lite/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,
+    disable_per_channel_for_dense_layers=False,
+    debug_options_str="",
+):
+  """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.
+    disable_per_channel_for_dense_layers: Bool indicating whether to do
+      per-channel or per-tensor quantization in Fully Connected layers. Default
+      value is False meaning per-channel quantization is enabled.
+    debug_options_str: Serialized proto describing TFLite converter debug
+      options, see `debug/debug_options.proto`.
+
+  Returns:
+    Quantized model in serialized form (e.g. a TFLITE model) with floating-point
+    inputs and outputs.
+  """
+  return wrap_converter.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,
+      disable_per_channel_for_dense_layers,
+      debug_options_str,
+  )
+
+
+@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_converter.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_converter.wrapped_register_custom_opdefs(custom_opdefs_list)
+
+
+def convert(
+    model_flags: _model_flags_pb2.ModelFlags,
+    conversion_flags: _conversion_flags_pb2.ConverterFlags,
+    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
+      `compiler/mlir/lite/converter_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_converter.wrapped_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 `compiler/mlir/lite/converter_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,
+    ir_dump_dir=None,
+    ir_dump_pass_regex=None,
+    ir_dump_func_regex=None,
+    enable_timing=None,
+    print_ir_before=None,
+    print_ir_after=None,
+    print_ir_module_scope=None,
+    elide_elementsattrs_if_larger=None,
+    quantization_config: Optional[
+        quantization_config_pb2.QuantizationConfig
+    ] = None,
+    use_buffer_offset=False,
+    reduce_type_precision=False,
+    qdq_conversion_mode=None,
+    disable_per_channel_quantization_for_dense_layers=False,
+    enable_composite_direct_lowering=False,
+    model_origin_framework=lite_constants.UNSET,
+    canonicalizing_inf_as_min_max_float=True,
+    **_,
+):
+  """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: [Deprecated] 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.
+    ir_dump_dir: A string specifying the target directory to output MLIR dumps
+      produced during conversion. If populated, enables MLIR dumps.
+    ir_dump_pass_regex: A string containing a regular expression for filtering
+      the pass names to be dumped. Effective only if `ir_dump_dir` is populated.
+    ir_dump_func_regex: A string containing a regular expression for filtering
+      the function names to be dumped. Effective only if `ir_dump_dir` is
+      populated.
+    enable_timing: A boolean, if set to true reports the execution time of each
+      MLIR pass.
+    print_ir_before: A string containing a regular expression. If specified,
+      prints MLIR before passes which match.
+    print_ir_after: A string containing a regular expression. If specified,
+      prints MLIR after passes which match.
+    print_ir_module_scope: A boolean, if set to true always print the top-level
+      operation when printing IR for print_ir_[before|after].
+    elide_elementsattrs_if_larger: An int, if specified elides ElementsAttrs
+      with '...' that have more elements than the given upper limit.
+    quantization_config: Configures the StableHLO Quantizer. See the comments in
+      `QuantizationConfig` protobuf definition for details.
+    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.
+    qdq_conversion_mode: If set, assume input model is a quantized model
+      represented with QDQ ops and convert to quantized kernels.
+    disable_per_channel_quantization_for_dense_layers: If set, disables per
+      channel end enables per tensor integer quantization for weights in Dense
+      layers. The flag works only for integer quantized model.
+    enable_composite_direct_lowering: If set, attempts to lower composite ops
+      directly to tflite ops.
+    model_origin_framework: A str specifying the framework of the original
+      model. Can be {TENSORFLOW, KERAS, JAX, PYTORCH}
+    canonicalizing_inf_as_min_max_float: When set to true, convert +Inf/-Inf to
+      MIN/MAX float value and output of converter only contains finite values.
+
+  Returns:
+    conversion_flags: protocol buffer describing the conversion process.
+  Raises:
+    ValueError, if the input tensor type is unknown.
+  """
+  conversion_flags = _conversion_flags_pb2.ConverterFlags()
+  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:  # Deprecated
+    conversion_flags.quantization_options.CopyFrom(quantization_options)
+  if quantization_config:
+    conversion_flags.quantization_config.CopyFrom(quantization_config)
+
+  # Transfer debug options. Check for existence before populating in order to
+  # leverage defaults specified in proto definition.
+  # TODO: b/319329480 - Match the debug_options fields with the user-facing
+  # flags.
+  if ir_dump_dir is not None:
+    conversion_flags.debug_options.ir_dump_dir = ir_dump_dir
+  if ir_dump_pass_regex is not None:
+    conversion_flags.debug_options.ir_dump_pass_regex = ir_dump_pass_regex
+  if ir_dump_func_regex is not None:
+    conversion_flags.debug_options.ir_dump_func_regex = ir_dump_func_regex
+  if enable_timing is not None:
+    conversion_flags.debug_options.enable_timing = enable_timing
+  if print_ir_before is not None:
+    conversion_flags.debug_options.print_ir_before = print_ir_before
+  if print_ir_after is not None:
+    conversion_flags.debug_options.print_ir_after = print_ir_after
+  if print_ir_module_scope is not None:
+    conversion_flags.debug_options.print_ir_module_scope = print_ir_module_scope
+  if elide_elementsattrs_if_larger is not None:
+    conversion_flags.debug_options.elide_elementsattrs_if_larger = (
+        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
+  if qdq_conversion_mode is not None:
+    conversion_flags.qdq_conversion_mode = qdq_conversion_mode
+  conversion_flags.disable_per_channel_quantization_for_dense_layers = (
+      disable_per_channel_quantization_for_dense_layers
+  )
+  conversion_flags.enable_composite_direct_lowering = (
+      enable_composite_direct_lowering
+  )
+  conversion_flags.model_origin_framework = (
+      _conversion_flags_pb2.ConverterFlags.ModelOriginFramework.Value(
+          model_origin_framework
+      )
+  )
+  conversion_flags.canonicalizing_inf_as_min_max_float = (
+      canonicalizing_inf_as_min_max_float
+  )
+  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)

SwarmUI/dlbackend/ComfyUI/venv/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