onnx2tf 1.29.19__py3-none-any.whl → 1.29.21__py3-none-any.whl

onnx2tf/ops/GatherElements.py

@@ -57,9 +57,10 @@ def make_node(
         graph_node.inputs[0],
         before_op_output_shape_trans,
     )
+    # Indices must not be layout-transposed.
     graph_node_input_2 = get_constant_or_variable(
         graph_node.inputs[1],
-        before_op_output_shape_trans,
+        False,
     )
     graph_node_output: gs.Variable = graph_node.outputs[0]
     shape = graph_node_output.shape
@@ -77,12 +78,29 @@ def make_node(
         param_name=graph_node.inputs[0].name,
         **kwargs,
     )
-    indices_tensor = pre_process_transpose(
-        value_before_transpose=indices_tensor,
-        param_target='inputs',
-        param_name=graph_node.inputs[1].name,
-        **kwargs,
-    )
+    # If input is transposed by replacement params, align indices tensor shape.
+    op_rep_params = kwargs.get('op_rep_params', [])
+    params_perm = None
+    indices_perm = None
+    for op_rep_param in op_rep_params:
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[0].name:
+            params_perm = op_rep_param.get('pre_process_transpose_perm', None)
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[1].name:
+            indices_perm = op_rep_param.get('pre_process_transpose_perm', None)
+    target_perm = indices_perm if indices_perm is not None else params_perm
+    if target_perm is not None:
+        try:
+            rank = len(indices_tensor.shape) if hasattr(indices_tensor, "shape") else None
+            if rank is None or rank == len(target_perm):
+                indices_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=indices_tensor,
+                    perm=target_perm,
+                    **kwargs,
+                )
+        except Exception:
+            pass
 
     tensor_rank = len(input_tensor.shape)
 

onnx2tf/ops/GatherND.py

@@ -51,9 +51,10 @@ def make_node(
         graph_node.inputs[0],
         before_op_output_shape_trans,
     )
+    # Indices must not be layout-transposed.
     graph_node_input_2 = get_constant_or_variable(
         graph_node.inputs[1],
-        before_op_output_shape_trans,
+        False,
     )
     graph_node_output: gs.Variable = graph_node.outputs[0]
     shape = graph_node_output.shape
@@ -89,6 +90,32 @@ def make_node(
 
     replace_gathernd_to_pseudo_gathernd = "gathernd" in kwargs['replace_to_pseudo_operators']
 
+    # If params is transposed, adjust indices to match the transposed layout.
+    op_rep_params = kwargs.get('op_rep_params', [])
+    params_perm = None
+    indices_perm_specified = False
+    for op_rep_param in op_rep_params:
+        if op_rep_param['param_target'] == 'inputs' and op_rep_param['param_name'] == graph_node.inputs[0].name:
+            params_perm = op_rep_param.get('pre_process_transpose_perm', None)
+        if op_rep_param['param_target'] == 'inputs' and op_rep_param['param_name'] == graph_node.inputs[1].name:
+            if op_rep_param.get('pre_process_transpose_perm', None) is not None:
+                indices_perm_specified = True
+    if params_perm is not None and not indices_perm_specified:
+        # Only handle standard layout swaps that keep batch dims at the front.
+        if batch_dims <= len(params_perm) \
+            and list(params_perm[:batch_dims]) == list(range(batch_dims)):
+            perm_tail = [p - batch_dims for p in params_perm if p >= batch_dims]
+            try:
+                if isinstance(indices_tensor, np.ndarray):
+                    if indices_tensor.shape and indices_tensor.shape[-1] == len(perm_tail):
+                        indices_tensor = indices_tensor[..., perm_tail]
+                else:
+                    idx_last = indices_tensor.shape[-1] if indices_tensor.shape is not None else None
+                    if idx_last is None or idx_last == len(perm_tail):
+                        indices_tensor = tf.gather(indices_tensor, perm_tail, axis=-1)
+            except Exception:
+                pass
+
     # Preserving Graph Structure (Dict)
     tf_layers_dict[graph_node_output.name] = {
         'optype': graph_node.op,

onnx2tf/ops/ScatterElements.py

@@ -55,9 +55,10 @@ def make_node(
         graph_node.inputs[0],
         before_op_output_shape_trans,
     )
+    # Indices must not be layout-transposed.
     graph_node_input_2 = get_constant_or_variable(
         graph_node.inputs[1],
-        before_op_output_shape_trans,
+        False,
     )
     graph_node_input_3 = get_constant_or_variable(
         graph_node.inputs[2],
@@ -81,12 +82,29 @@ def make_node(
     indices_tensor = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
         if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
     # Pre-process transpose
-    indices_tensor = pre_process_transpose(
-        value_before_transpose=indices_tensor,
-        param_target='inputs',
-        param_name=graph_node.inputs[1].name,
-        **kwargs,
-    )
+    # If input is transposed by replacement params, align indices tensor shape.
+    op_rep_params = kwargs.get('op_rep_params', [])
+    params_perm = None
+    indices_perm = None
+    for op_rep_param in op_rep_params:
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[0].name:
+            params_perm = op_rep_param.get('pre_process_transpose_perm', None)
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[1].name:
+            indices_perm = op_rep_param.get('pre_process_transpose_perm', None)
+    target_perm = indices_perm if indices_perm is not None else params_perm
+    if target_perm is not None:
+        try:
+            rank = len(indices_tensor.shape) if hasattr(indices_tensor, "shape") else None
+            if rank is None or rank == len(target_perm):
+                indices_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=indices_tensor,
+                    perm=target_perm,
+                    **kwargs,
+                )
+        except Exception:
+            pass
     updates_tensor = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
         if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
     # Pre-process transpose

onnx2tf/ops/ScatterND.py

@@ -13,6 +13,7 @@ from onnx2tf.utils.common_functions import (
     get_replacement_parameter,
     pre_process_transpose,
     post_process_transpose,
+    transpose_with_flexing_deterrence,
 )
 
 
@@ -79,6 +80,32 @@ def make_node(
                 and 'nhwc' in tf_layers_dict[graph_node_input_1.name].keys() else False
     }
 
+    op_rep_params = kwargs.get('op_rep_params', [])
+    params_perm = None
+    indices_perm = None
+    for op_rep_param in op_rep_params:
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[0].name:
+            params_perm = op_rep_param.get('pre_process_transpose_perm', None)
+        if op_rep_param['param_target'] == 'inputs' \
+            and op_rep_param['param_name'] == graph_node.inputs[1].name:
+            indices_perm = op_rep_param.get('pre_process_transpose_perm', None)
+
+    def reorder_indices_last_dim(target_indices, perm):
+        if perm is None:
+            return target_indices
+        try:
+            if isinstance(target_indices, np.ndarray):
+                if target_indices.shape and target_indices.shape[-1] == len(perm):
+                    return target_indices[..., perm]
+            else:
+                idx_last = target_indices.shape[-1] if target_indices.shape is not None else None
+                if idx_last is None or idx_last == len(perm):
+                    return tf.gather(target_indices, perm, axis=-1)
+        except Exception:
+            pass
+        return target_indices
+
     # Pre-process transpose
     input_tensor = pre_process_transpose(
         value_before_transpose=input_tensor,
@@ -86,18 +113,26 @@ def make_node(
         param_name=graph_node.inputs[0].name,
         **kwargs,
     )
-    indices_tensor = pre_process_transpose(
-        value_before_transpose=indices_tensor,
-        param_target='inputs',
-        param_name=graph_node.inputs[1].name,
-        **kwargs,
-    )
+    # Indices must not be layout-transposed; apply explicit perm only if specified.
+    if indices_perm is not None:
+        try:
+            rank = len(indices_tensor.shape) if hasattr(indices_tensor, "shape") else None
+            if rank is None or rank == len(indices_perm):
+                indices_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=indices_tensor,
+                    perm=indices_perm,
+                    **kwargs,
+                )
+        except Exception:
+            pass
     updates_tensor = pre_process_transpose(
         value_before_transpose=updates_tensor,
         param_target='inputs',
         param_name=graph_node.inputs[2].name,
         **kwargs,
     )
+    if params_perm is not None and indices_perm is None:
+        indices_tensor = reorder_indices_last_dim(indices_tensor, params_perm)
 
     # When NHWC is fixed, return to NCHW format before processing.
     data_nhwc = tf_layers_dict[graph_node_input_1.name]['nhwc'] \
@@ -119,6 +154,8 @@ def make_node(
         and len(input_tensor.shape) >= 3:
         perm = [0, len(input_tensor.shape)-1] + [i for i in range(1, len(input_tensor.shape)-1)]
         input_tensor = tf.transpose(a=input_tensor, perm=perm)
+        if indices_perm is None:
+            indices_tensor = reorder_indices_last_dim(indices_tensor, perm)
         nchw = True
     elif not data_nhwc \
         and len(input_tensor.shape) >= 3 \
@@ -126,6 +163,8 @@ def make_node(
         and input_tensor.shape != graph_node.inputs[0].shape:
         perm = [0, len(input_tensor.shape)-1] + [i for i in range(1, len(input_tensor.shape)-1)]
         input_tensor = tf.transpose(a=input_tensor, perm=perm)
+        if indices_perm is None:
+            indices_tensor = reorder_indices_last_dim(indices_tensor, perm)
         nchw = True
     ## indices
     if indices_nhwc \

onnx2tf/ops/TensorScatter.py

@@ -14,6 +14,7 @@ from onnx2tf.utils.common_functions import (
     get_replacement_parameter,
     pre_process_transpose,
     post_process_transpose,
+    transpose_with_flexing_deterrence,
 )
 from onnx2tf.utils.enums import NUMPY_DTYPES_TO_TF_DTYPES
 from onnx2tf.utils.logging import *
@@ -112,12 +113,25 @@ def make_node(
         **kwargs,
     )
     if write_indices is not None:
-        write_indices = pre_process_transpose(
-            value_before_transpose=write_indices,
-            param_target='inputs',
-            param_name=graph_node.inputs[2].name,
-            **kwargs,
-        )
+        # Indices must not be layout-transposed; apply explicit perm only if specified.
+        op_rep_params = kwargs.get('op_rep_params', [])
+        indices_perm = None
+        for op_rep_param in op_rep_params:
+            if op_rep_param['param_target'] == 'inputs' \
+                and op_rep_param['param_name'] == graph_node.inputs[2].name:
+                indices_perm = op_rep_param.get('pre_process_transpose_perm', None)
+                break
+        if indices_perm is not None:
+            try:
+                rank = len(write_indices.shape) if hasattr(write_indices, "shape") else None
+                if rank is None or rank == len(indices_perm):
+                    write_indices = transpose_with_flexing_deterrence(
+                        input_tensor=write_indices,
+                        perm=indices_perm,
+                        **kwargs,
+                    )
+            except Exception:
+                pass
 
     # Generation of TF OP
     past_cache = _as_tensor(past_cache)

onnx2tf/utils/common_functions.py

@@ -1,4 +1,5 @@
 import math
+import ast
 import os
 import io
 import re
@@ -26,6 +27,7 @@ from tensorflow.python.keras.layers import Lambda
 from tensorflow.python.keras.utils import conv_utils
 import onnx
 from onnx.serialization import ProtoSerializer
+from onnx.external_data_helper import uses_external_data
 import onnx_graphsurgeon as gs
 try:
     import onnxruntime as ort
@@ -44,6 +46,61 @@ from onnx2tf.utils.enums import (
 INF_INDEX_VALUE: int = 4294967296
 ONNX_INF_INDEX_VALUE = sys.maxsize # 9223372036854775807
 
+_DEFAULT_DUMMY_SHAPE_HINTS: Optional[List[str]] = None
+_DEFAULT_DUMMY_VALUE_HINTS: Optional[List[str]] = None
+
+
+def set_dummy_shape_hints(shape_hints: Optional[List[str]]) -> None:
+    global _DEFAULT_DUMMY_SHAPE_HINTS
+    _DEFAULT_DUMMY_SHAPE_HINTS = shape_hints
+
+
+def set_dummy_value_hints(value_hints: Optional[List[str]]) -> None:
+    global _DEFAULT_DUMMY_VALUE_HINTS
+    _DEFAULT_DUMMY_VALUE_HINTS = value_hints
+
+
+def _parse_value_hint_scalar(value: str) -> Optional[Any]:
+    try:
+        parsed = ast.literal_eval(value)
+    except Exception:
+        try:
+            parsed = float(value)
+        except Exception:
+            return None
+    if isinstance(parsed, (list, tuple, dict, set, np.ndarray)):
+        return None
+    if isinstance(parsed, (int, float, bool, np.number)):
+        return parsed
+    return None
+
+
+def _parse_value_hints(
+    value_hints: Optional[List[str]]
+) -> Tuple[Dict[str, Any], Optional[Any], bool]:
+    if not value_hints:
+        return {}, None, False
+    hints: Dict[str, Any] = {}
+    default_value: Optional[Any] = None
+    for hint in value_hints:
+        if not isinstance(hint, str):
+            continue
+        parts = hint.split(':', 1)
+        if len(parts) != 2:
+            continue
+        input_name, value_str = parts[0], parts[1]
+        parsed_value = _parse_value_hint_scalar(value_str)
+        if parsed_value is None:
+            warn(f'Invalid --value_hints entry ignored: {hint}')
+            continue
+        if input_name == '*':
+            default_value = parsed_value
+        else:
+            hints[input_name] = parsed_value
+    return hints, default_value, default_value is not None
+
+
+
 
 def get_replacement_parameter(func):
     @wraps(func)
@@ -3851,6 +3908,7 @@ def dummy_onnx_inference(
     enable_ort_output_memmap: bool = False,
     ort_output_memmap_dir: Optional[str] = None,
     shape_hints: Optional[List[str]] = None,
+    value_hints: Optional[List[str]] = None,
     input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
 ) -> List[np.ndarray]:
     """Perform inference on ONNX subgraphs with an all-1 dummy tensor.
@@ -3888,6 +3946,10 @@ def dummy_onnx_inference(
         Directory to store memmap files. If not specified, a temporary
         directory is created and removed on exit.
 
+    value_hints: Optional[List[str]]
+        Value hints for dummy inference input tensors.
+        Format: ["input_name:value", "*:default_value"].
+
     input_datas_for_validation: Optional[Dict[str, np.ndarray]]
         Optional dict to be filled with the input tensors used for inference.
 
@@ -3896,6 +3958,11 @@ def dummy_onnx_inference(
     outputs: List[np.ndarray]
         Results of inference using dummy tensor
     """
+    if shape_hints is None:
+        shape_hints = _DEFAULT_DUMMY_SHAPE_HINTS
+    if value_hints is None:
+        value_hints = _DEFAULT_DUMMY_VALUE_HINTS
+
     # Separate onnx at specified output_names position
     domain: str = onnx_graph.domain
     ir_version: int = onnx_graph.ir_version
@@ -4046,7 +4113,11 @@ def dummy_onnx_inference(
                 input_sizes[i] = updated_shape
 
     input_dtypes: List[Any] = [inp.dtype for inp in onnx_inputs]
+    input_size_map = {
+        name: tuple(size) for name, size in zip(input_names, input_sizes)
+    }
     input_datas = {}
+    value_hints_dict, default_value, has_default = _parse_value_hints(value_hints)
 
     # -cid
     if custom_input_op_name_np_data_path:
@@ -4059,7 +4130,16 @@ def dummy_onnx_inference(
             if input_op_info is not None:
                 ncw_nchw_ncdhw_perm: List = input_op_info.get('ncw_nchw_ncdhw_perm', None)
                 if ncw_nchw_ncdhw_perm is not None:
-                    custom_input_data = custom_input_data.transpose(ncw_nchw_ncdhw_perm)
+                    expected_shape = input_size_map.get(
+                        input_op_name,
+                        tuple(custom_input_data.shape),
+                    )
+                    if tuple(custom_input_data.shape) != expected_shape:
+                        permuted_shape = tuple(
+                            custom_input_data.shape[i] for i in ncw_nchw_ncdhw_perm
+                        )
+                        if permuted_shape == expected_shape:
+                            custom_input_data = custom_input_data.transpose(ncw_nchw_ncdhw_perm)
                 onnx_batch_size = input_op_info['shape'][0]
                 cdata_batch_size = custom_input_data.shape[0]
                 if isinstance(onnx_batch_size, int) and onnx_batch_size != cdata_batch_size and cdata_batch_size > 1:
@@ -4071,7 +4151,17 @@ def dummy_onnx_inference(
 
     else:
         for input_name, input_size, input_dtype in zip(input_names, input_sizes, input_dtypes):
-            if test_data_nhwc is None:
+            hint_value = value_hints_dict.get(
+                input_name,
+                default_value if has_default else None,
+            )
+            if hint_value is not None:
+                input_datas[input_name] = np.full(
+                    input_size,
+                    hint_value,
+                    dtype=input_dtype,
+                )
+            elif test_data_nhwc is None:
                 input_datas[input_name] = np.ones(
                     input_size,
                     dtype=input_dtype,
@@ -4230,7 +4320,9 @@ def dummy_tf_inference(
     verification_datas: Optional[List[np.ndarray]] = None,
     custom_input_op_name_np_data_path: Optional[str] = None,
     shape_hints: Optional[List[str]] = None,
+    value_hints: Optional[List[str]] = None,
     input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
+    prefilled_input_datas: Optional[Dict[str, np.ndarray]] = None,
     keep_shape_absolutely_input_names: Optional[List[str]] = None,
     keep_ncw_or_nchw_or_ncdhw_input_names: Optional[List[str]] = None,
     keep_nwc_or_nhwc_or_ndhwc_input_names: Optional[List[str]] = None,
@@ -4253,6 +4345,11 @@ def dummy_tf_inference(
 
     custom_input_op_name_np_data_path
         Path to Numpy file for custom data used for dummy inference
+
+    value_hints: Optional[List[str]]
+        Value hints for dummy inference input tensors.
+        Format: ["input_name:value", "*:default_value"].
+
     input_datas_for_validation: Optional[Dict[str, np.ndarray]]
         Optional dict to be filled with the input tensors used for inference.
 
@@ -4262,8 +4359,15 @@ def dummy_tf_inference(
         Results of inference using dummy tensor.
         Dict of tensorflow node and corresponding ndarray output.
     """
+    if shape_hints is None:
+        shape_hints = _DEFAULT_DUMMY_SHAPE_HINTS
+    if value_hints is None:
+        value_hints = _DEFAULT_DUMMY_VALUE_HINTS
+
     input_names: List[str] = [inp.name for inp in inputs]
     input_sizes: List[int] = [inp.shape for inp in inputs]
+    input_size_map = {name: size for name, size in zip(input_names, input_sizes)}
+    input_index_map = {name: i for i, name in enumerate(input_names)}
 
     if shape_hints is None:
         new_input_sizes = []
@@ -4335,13 +4439,24 @@ def dummy_tf_inference(
 
     input_dtypes: List[Any] = [inp.dtype for inp in inputs]
     input_datas = {}
+    value_hints_dict, default_value, has_default = _parse_value_hints(value_hints)
 
     # -cid
     if custom_input_op_name_np_data_path:
-        for idx, param in enumerate(custom_input_op_name_np_data_path):
+        for param in custom_input_op_name_np_data_path:
+            if len(param) < 2:
+                continue
+            input_name = str(param[0])
             numpy_file_path = str(param[1])
+            if input_name not in input_index_map:
+                continue
+            idx = input_index_map[input_name]
+            tf_input_name = input_names[idx]
+            if prefilled_input_datas and tf_input_name in prefilled_input_datas:
+                continue
             custom_input_data = np.load(numpy_file_path)
             input_size = input_sizes[idx]
+            input_dtype = input_dtypes[idx] if idx < len(input_dtypes) else np.float32
 
             tf_batch_size = input_size[0]
             cdata_batch_size = custom_input_data.shape[0]
@@ -4351,6 +4466,24 @@ def dummy_tf_inference(
                 custom_input_data = custom_input_data[0:1, ...]
 
             if list(custom_input_data.shape) != input_size:
+                auto_split_input = (
+                    'onnx2tf_split_' in numpy_file_path
+                    or os.path.basename(numpy_file_path).startswith('part_')
+                )
+                if auto_split_input:
+                    warn(
+                        'Auto-split custom input shape does not match TF input shape. '
+                        f'input_name={input_name} '
+                        f'tf_shape={input_size} '
+                        f'numpy_shape={list(custom_input_data.shape)} '
+                        f'path={numpy_file_path} '
+                        'Fallback to dummy input for this tensor.'
+                    )
+                    input_datas[input_names[idx]] = np.ones(
+                        input_size,
+                        dtype=TF_DTYPES_TO_NUMPY_DTYPES[input_dtype],
+                    )
+                    continue
                 error_msg = f'' + \
                     Color.RED(f'ERROR:') + ' ' + \
                     f"The format of custom input data is different from Tensorflow's format. " + \
@@ -4363,7 +4496,17 @@ def dummy_tf_inference(
     else:
         if verification_datas is None:
             for input_name, input_size, input_dtype in zip(input_names, input_sizes, input_dtypes):
-                if test_data_nhwc is None:
+                hint_value = value_hints_dict.get(
+                    input_name,
+                    default_value if has_default else None,
+                )
+                if hint_value is not None:
+                    input_datas[input_name] = np.full(
+                        input_size,
+                        hint_value,
+                        dtype=TF_DTYPES_TO_NUMPY_DTYPES[input_dtype],
+                    )
+                elif test_data_nhwc is None:
                     input_datas[input_name] = np.ones(
                         input_size,
                         dtype=TF_DTYPES_TO_NUMPY_DTYPES[input_dtype],
@@ -4397,6 +4540,33 @@ def dummy_tf_inference(
     if input_datas_for_validation is not None:
         input_datas_for_validation.update(input_datas)
 
+    if prefilled_input_datas:
+        for input_name, input_data in prefilled_input_datas.items():
+            expected = None
+            if input_name in input_datas:
+                expected = input_datas[input_name].shape
+            elif input_name in input_size_map:
+                expected = input_size_map[input_name]
+            else:
+                continue
+            data = input_data
+            try:
+                if expected is not None and tuple(data.shape) != tuple(expected):
+                    if data.size == np.prod(expected):
+                        data = data.reshape(expected)
+                    else:
+                        continue
+                target_dtype = None
+                if input_name in input_datas:
+                    target_dtype = input_datas[input_name].dtype
+                elif input_name in input_index_map:
+                    target_dtype = input_dtypes[input_index_map[input_name]]
+                if target_dtype is not None and data.dtype != target_dtype:
+                    data = data.astype(target_dtype)
+                input_datas[input_name] = data
+            except Exception:
+                continue
+
     outputs = model(
         inputs={
             input.name: input_datas[input.name] for input in inputs
@@ -6057,6 +6227,8 @@ def acquisition_of_validation_data(
         kwargs['test_data_nhwc']
     custom_input_op_name_np_data_path: str = \
         kwargs['custom_input_op_name_np_data_path']
+    tf_input_cache: Optional[Dict[str, np.ndarray]] = \
+        kwargs.get('tf_input_cache', None)
 
     # Get the output tensor of one previous OP of TensorFlow only once
     tf_model_inputs = get_tf_model_inputs(
@@ -6108,6 +6280,7 @@ def acquisition_of_validation_data(
             inputs=tf_model_inputs,
             test_data_nhwc=test_data_nhwc,
             custom_input_op_name_np_data_path=custom_input_op_name_np_data_path,
+            prefilled_input_datas=tf_input_cache,
         )
     except Exception as ex:
         pass
@@ -6526,3 +6699,24 @@ def define_reduceXXX(
             keepdims=target_keepdims,
         )
     return reduced_tensor
+
+def check_has_external_data(input_onnx_file_path: str) -> bool:
+    model = onnx.load(input_onnx_file_path, load_external_data=False)
+    def iter_tensors_in_graph(g):
+        for t in g.initializer:
+            yield t
+        for t in g.sparse_initializer:
+            yield t
+        for n in g.node:
+            for a in n.attribute:
+                if a.type == onnx.AttributeProto.TENSOR:
+                    yield a.t
+                elif a.type == onnx.AttributeProto.TENSORS:
+                    for t in a.tensors:
+                        yield t
+                elif a.type == onnx.AttributeProto.GRAPH:
+                    yield from iter_tensors_in_graph(a.g)
+                elif a.type == onnx.AttributeProto.GRAPHS:
+                    for sg in a.graphs:
+                        yield from iter_tensors_in_graph(sg)
+    return any(uses_external_data(t) for t in iter_tensors_in_graph(model.graph))