code: def export(
      preprocessor: Union[
          "PreTrainedTokenizer",
          "FeatureExtractionMixin",
          "ProcessorMixin",
      ],
      model: Union["PreTrainedModel", "TFPreTrainedModel"],
      config: OnnxConfig,
      opset: int,
      output: Path,
      tokenizer: "PreTrainedTokenizer" = None,
      device: str = "cpu",
  ) -> Tuple[List[str], List[str]]:
      """
      Export a Pytorch or TensorFlow model to an ONNX Intermediate Representation (IR)
  
      Args:
          preprocessor: ([`PreTrainedTokenizer`], [`FeatureExtractionMixin`] or [`ProcessorMixin`]):
              The preprocessor used for encoding the data.
          model ([`PreTrainedModel`] or [`TFPreTrainedModel`]):
              The model to export.
          config ([`~onnx.config.OnnxConfig`]):
              The ONNX configuration associated with the exported model.
          opset (`int`):
              The version of the ONNX operator set to use.
          output (`Path`):
              Directory to store the exported ONNX model.
          device (`str`, *optional*, defaults to `cpu`):
              The device on which the ONNX model will be exported. Either `cpu` or `cuda`. Only PyTorch is supported for
              export on CUDA devices.
  
      Returns:
          `Tuple[List[str], List[str]]`: A tuple with an ordered list of the model's inputs, and the named inputs from
          the ONNX configuration.
      """
      if not (is_torch_available() or is_tf_available()):
          raise ImportError(
              "Cannot convert because neither PyTorch nor TensorFlow are not installed. "
              "Please install torch or tensorflow first."
          )
  
      if (
          is_tf_available()
          and isinstance(model, TFPreTrainedModel)
          and device == "cuda"
      ):
          raise RuntimeError(
              "`tf2onnx` does not support export on CUDA device."
          )
  
      if (
          isinstance(preprocessor, PreTrainedTokenizerBase)
          and tokenizer is not None
      ):
          raise ValueError(
              "You cannot provide both a tokenizer and a preprocessor to export the model."
          )
      if tokenizer is not None:
          warnings.warn(
              "The `tokenizer` argument is deprecated and will be removed in version 5 of Transformers. Use"
              " `preprocessor` instead.",
              FutureWarning,
          )
          logger.info(
              "Overwriting the `preprocessor` argument with `tokenizer` to generate dummmy inputs."
          )
          preprocessor = tokenizer
  
      if is_torch_available():
          from ..utils import get_torch_version
  
          if not config.is_torch_support_available:
              logger.warning(
                  f"Unsupported PyTorch version for this model. Minimum required is {config.torch_onnx_minimum_version},"
                  f" got: {get_torch_version()}"
              )
  
      if is_torch_available() and issubclass(
          type(model), PreTrainedModel
      ):
          return export_pytorch(
              preprocessor,
              model,
              config,
              opset,
              output,
              tokenizer=tokenizer,
              device=device,
          )
      elif is_tf_available() and issubclass(
          type(model), TFPreTrainedModel
      ):
          return export_tensorflow(
              preprocessor,
              model,
              config,
              opset,
              output,
              tokenizer=tokenizer,
          )
  
file_path: transformers/src/transformers/onnx/convert.py
imports: import warnings
  from inspect import signature
  from itertools import chain
  from pathlib import Path
  from typing import TYPE_CHECKING, Iterable, List, Tuple, Union
  import numpy
  from packaging.version import Version, parse
  from ..tokenization_utils_base import PreTrainedTokenizerBase
  from ..utils import TensorType, is_tf_available, is_torch_available, logging
  from .config import OnnxConfig
label_desc: Use image node_id 4 for calling a global function with example usage: export(preprocessor, model, config, opset, output, tokenizer, device) and returns: export_pytorch, export_tensorflow