code: def _export(
      filename,
      model,
      image_input_names=[],
      is_bgr=False,
      red_bias=0.0,
      blue_bias=0.0,
      green_bias=0.0,
      gray_bias=0.0,
      image_scale=1.0,
      class_labels=None,
      predicted_feature_name=None,
  ):
      from ... import libcaffeconverter
  
      if isinstance(model, _six.string_types):
          src_model_path = model
          prototxt_path = ""
          binaryproto_path = dict()
      elif isinstance(model, tuple):
          if len(model) == 3:
              src_model_path, prototxt_path, binaryproto_path = model
          else:
              src_model_path, prototxt_path = model
              binaryproto_path = dict()
  
      if isinstance(image_input_names, _six.string_types):
          image_input_names = [image_input_names]
      if predicted_feature_name is None:
          predicted_feature_name = "classLabel"
      if class_labels is None:
          class_labels = ""
  
      if binaryproto_path:
          if not image_input_names:
              raise RuntimeError(
                  "'image_input_names' must be provided when a mean image binaryproto path is specified. "
              )
  
      if isinstance(binaryproto_path, _six.string_types):
          binaryproto_paths = dict()
          binaryproto_paths[image_input_names[0]] = binaryproto_path
      elif isinstance(binaryproto_path, dict):
          binaryproto_paths = binaryproto_path
      else:
          raise RuntimeError(
              "Mean image binaryproto path must be a string or a dictionary of inputs names and paths. "
          )
  
      if not isinstance(is_bgr, dict):
          is_bgr = dict.fromkeys(image_input_names, is_bgr)
      if not isinstance(red_bias, dict):
          red_bias = dict.fromkeys(image_input_names, red_bias)
      if not isinstance(blue_bias, dict):
          blue_bias = dict.fromkeys(image_input_names, blue_bias)
      if not isinstance(green_bias, dict):
          green_bias = dict.fromkeys(image_input_names, green_bias)
      if not isinstance(gray_bias, dict):
          gray_bias = dict.fromkeys(image_input_names, gray_bias)
      if not isinstance(image_scale, dict):
          image_scale = dict.fromkeys(image_input_names, image_scale)
  
      libcaffeconverter._convert_to_file(
          src_model_path,
          filename,
          binaryproto_paths,
          set(image_input_names),
          is_bgr,
          red_bias,
          blue_bias,
          green_bias,
          gray_bias,
          image_scale,
          prototxt_path,
          class_labels,
          predicted_feature_name,
      )
  
imports: import os
  import six
  from ...models import _MLMODEL_FULL_PRECISION, _MLMODEL_HALF_PRECISION, _VALID_MLMODEL_PRECISION_TYPES
label_desc: Use image node_id 2 for calling a global function with example usage: _export(filename, model, image_input_names, is_bgr, red_bias, blue_bias, green_bias, gray_bias, image_scale, class_labels, predicted_feature_name) without return types