code: def to_native(
      x: Union[ivy.Array, ivy.NativeArray, Iterable],
      nested: bool = False,
      include_derived: Optional[Dict[str, bool]] = None,
      cont_inplace: bool = False,
      to_ignore: Optional[Union[type, Tuple[type]]] = None,
  ) -> Union[ivy.Array, ivy.NativeArray, Iterable]:
      """Return the input item in its native backend framework form if it is an
      ivy.Array instance, otherwise the input is returned unchanged. If nested is
      set, the check is applied to all nested leaves of tuples, lists and dicts
      contained within ``x``.
  
      Parameters
      ----------
      x
          The input to maybe convert.
      nested
          Whether to apply the conversion on arguments in a nested manner. If so, all
          dicts, lists and tuples will be traversed to their lowest leaves in search of
          ivy.Array instances. Default is ``False``.
      include_derived
          Whether to also recursive for classes derived from tuple, list and dict.
          Default is ``False``.
      cont_inplace
          Whether to update containers in place. Default is ``False``
      to_ignore
          Types to ignore when deciding whether to go deeper into the nest or not
  
      Returns
      -------
       ret
          the input in its native framework form in the case of ivy.Array instances.
      """
      if nested:
          return ivy.nested_map(
              lambda x: _to_native(
                  x, inplace=cont_inplace, to_ignore=to_ignore
              ),
              x,
              include_derived,
              shallow=False,
          )
      return _to_native(x, inplace=cont_inplace, to_ignore=to_ignore)
  
file_path: ivy/ivy/data_classes/array/conversions.py
imports: import numpy
  from typing import Any, Union, Tuple, Dict, Iterable, Optional
  import ivy
label_desc: Use image node_id 7 for calling a global function with example usage: to_native(x, nested, include_derived, cont_inplace, to_ignore) and returns: _to_native, ivy