code: def convert_args_to_tensor(args, dtype=None, name=None):
      """Converts `args` to `Tensor`s.
  
      Use this when it is necessary to convert user-provided arguments that will
      then be passed to user-provided callables.
  
      When `dtype` is `None` this function behaves as follows:
  
      1A. If the top-level structure is a `list`/`tuple` but not a `namedtuple`,
          then it is left as is and only its elements are converted to `Tensor`s.
  
      2A. The sub-structures are converted to `Tensor`s eagerly. E.g. if `args` is
          `{'arg': [[1], [2]]}` it is converted to
          `{'arg': tf.constant([[1], [2]])}`. If the conversion fails, it will
          attempt to recurse into its children.
  
      When `dtype` is specified, it acts as both a structural and numeric type
      constraint. `dtype` can be a single `DType`, `None` or a nested collection
      thereof. The conversion rule becomes as follows:
  
      1B. The return value of this function will have the same structure as `dtype`.
  
      2B. If the leaf of `dtype` is a concrete `DType`, then the corresponding
          sub-structure in `args` is converted to a `Tensor`.
  
      3B. If the leaf of `dtype` is `None`, then the corresponding sub-structure is
          converted eagerly as described in the rule 2A above.
  
      Args:
        args: Arguments to convert to `Tensor`s.
        dtype: Optional structure/numeric type constraint.
        name: Optional name-scope to use.
  
      Returns:
        args: Converted `args`.
  
      #### Examples.
  
      This table shows some useful conversion cases. `T` means `Tensor`, `NT` means
      `namedtuple` and `CNT` means a `namedtuple` with a `Tensor`-conversion
      function registered.
  
      |     args     |    dtype   |       output       |
      |:------------:|:----------:|:------------------:|
      | `{"a": 1}`   | `None`     | `{"a": T(1)}`      |
      | `T(1)`       | `None`     | `T(1)`             |
      | `[1]`        | `None`     | `[T(1)]`           |
      | `[1]`        | `tf.int32` | `T([1])`           |
      | `[[T(1)]]`   | `None`     | `[T([1])]`         |
      | `[[T(1)]]`   | `[[None]]` | `[[T(1)]]`         |
      | `NT(1, 2)`   | `None`     | `NT(T(1), T(2))`   |
      | `NT(1, 2)`   | `tf.int32` | `T([1, 2])`        |
      | `CNT(1, 2)`  | `None`     | `T(...)`           |
      | `[[1, [2]]]` | `None`     | `[[T(1), T([2])]]` |
  
      """
      if dtype is None:
          if expand_as_args(args) or _expand_as_kwargs(args):
              shallow_args = _get_shallow_structure(args)
              return nest.map_structure_up_to(
                  shallow_args,
                  lambda s: _nested_convert_to_tensor(s, name=name),
                  args,
              )
          else:
              return _nested_convert_to_tensor(args, name=name)
      else:
          return nest.map_structure_up_to(
              dtype,
              lambda s, dtype: _nested_convert_to_tensor(
                  s, dtype, name
              ),
              args,
              dtype,
          )
  
imports: import collections
  import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensor_util
  from tensorflow.python.util import nest
label_desc: Use image node_id 12 for calling a global function with example usage: convert_args_to_tensor(args, dtype, name) and returns: nest, nest, _nested_convert_to_tensor