code: def _get_trace_graph(
      f,
      args=(),
      kwargs=None,
      strict=True,
      _force_outplace=False,
      return_inputs=False,
      _return_inputs_states=False,
  ):
      """Return a tuple on tracing a function or model.
  
      .. warning::
          This function is internal-only and should only be used by the ONNX
          exporter. If you are trying to get a graph through tracing, please go
          through the public API instead::
  
              trace = torch.jit.trace(nn.LSTMCell(), (input, hidden))
              trace_graph = trace.graph
  
      Trace a function or model, returning a tuple consisting of the both the
      *trace* of an execution, as well as the original return value. If return_inputs,
      also returns the trace inputs as part of the tuple
  
      Tracing is guaranteed not to change the semantics of the function/module
      that is traced.
  
      Args:
          f (torch.nn.Module or function): the function or module
              to be traced.
          args (tuple or Tensor): the positional arguments to pass to the
              function/module to be traced.  A non-tuple is assumed to
              be a single positional argument to be passed to the model.
          kwargs (dict): the keyword arguments to pass to the function/module
              to be traced.
  
      Example (trace a cell):
  
      .. testcode::
  
          trace = torch.jit.trace(nn.LSTMCell(), (input, hidden))
      """
      if kwargs is None:
          kwargs = {}
      if not isinstance(args, tuple):
          args = (args,)
      outs = ONNXTracedModule(
          f,
          strict,
          _force_outplace,
          return_inputs,
          _return_inputs_states,
      )(*args, **kwargs)
      return outs
  
imports: import contextlib
  import copy
  import functools
  import inspect
  import os
  import re
  import warnings
  from typing import Any, Callable, Dict, List, Optional, Set, TypeVar
  from typing_extensions import ParamSpec
  import torch
  from torch._jit_internal import _qualified_name, get_callable_argument_names, is_scripting
  from torch.autograd import function
  from torch.jit._script import _CachedForward, script, ScriptModule
  from torch.jit._state import _enabled, _python_cu
  from torch.nn import Module
  from torch.testing._comparison import default_tolerances
label_desc: Use image node_id 16 for calling a global function with example usage: _get_trace_graph(f, args, kwargs, strict, _force_outplace, return_inputs, _return_inputs_states) and returns: outs