code: def _validate_outputs_argument(outputs):
      """
      - validate properties that the "outputs" argument must satisfy, for instance, it should either be a list
        of ct.ImageType/ct.TensorType or a list of strings, etc.
      - return : tuple
          - (outputs_as_strings, outputs_as_tensor_or_image_types)
          - outputs_as_strings: list[str]
          - outputs_as_tensor_or_image_types : list[ct.ImageType] or list[ct.TensorType]
      """
      if outputs is None:
          return None, None
      else:
          if not isinstance(outputs, list):
              raise ValueError('"outputs" must be of type list')
          if len(outputs) == 0:
              return None, None
          if not all(
              map(
                  lambda t: isinstance(t, (ImageType, str, TensorType)),
                  outputs,
              )
          ):
              raise ValueError(
                  'Elements in "outputs" must be ct.TensorType or ct.ImageType or str'
              )
  
          msg_inconsistent_types = (
              'all elements of "outputs" must either be of type str '
              "or of types ct.ImageType/ct.TensorType"
          )
          if isinstance(outputs[0], str):
              # if one of the elements is a string, all elements must be strings
              if not all([isinstance(t, str) for t in outputs]):
                  raise ValueError(msg_inconsistent_types)
              return outputs, [
                  TensorType(name=name) for name in outputs
              ]
  
          if isinstance(outputs[0], InputType):
              if not all(
                  [
                      isinstance(t, TensorType)
                      or isinstance(t, ImageType)
                      for t in outputs
                  ]
              ):
                  raise ValueError(msg_inconsistent_types)
              if any([t.shape is not None for t in outputs]):
                  msg = (
                      "The 'shape' argument must not be specified for the outputs, since it is "
                      "automatically inferred from the input shapes and the ops in the model"
                  )
                  raise ValueError(msg)
              for out_ in outputs:
                  if isinstance(out_, TensorType):
                      if out_.default_value is not None:
                          raise ValueError(
                              "The 'default_value' argument must not be specified for the outputs"
                          )
                  if isinstance(out_, ImageType):
                      if out_.scale != 1.0:
                          raise ValueError(
                              "'scale' must be 1.0 for a output of ImageType"
                          )
                      if not (
                          out_.bias is None
                          or out_.bias == 0.0
                          or out_.bias == [0.0, 0.0, 0.0]
                      ):
                          raise ValueError(
                              "'bias' must be None or 0 for an output of ImageType"
                          )
                      if out_.channel_first is not None:
                          raise ValueError(
                              "'channel_first' must be None for an output of ImageType"
                          )
              output_names = [t.name for t in outputs]
              # verify that either all of the entries in output_names is "None" or none of them is "None"
              msg_consistent_names = 'Either none or all the outputs must have the "name" argument specified'
              if output_names[0] is None and not all(
                  [name is None for name in output_names]
              ):
                  raise ValueError(msg_consistent_names)
              if output_names[0] is not None and not all(
                  [name is not None for name in output_names]
              ):
                  raise ValueError(msg_consistent_names)
              if output_names[0] is not None:
                  if len(set(output_names)) != len(output_names):
                      raise ValueError(
                          "Duplicate names provided in 'outputs'"
                      )
              if output_names[0] is None:
                  return None, outputs
              else:
                  return output_names, outputs
  
imports: import collections
  import gc
  import os
  from typing import List, Optional, Text, Union
  from coremltools import _LOWEST_ALLOWED_SPECIFICATION_VERSION_FOR_MILPROGRAM, _LOWEST_ALLOWED_SPECIFICATION_VERSION_FOR_NEURALNETWORK
  from coremltools import ComputeUnit
  from coremltools import __version__
  from coremltools import _logger
  from coremltools._deps import _HAS_TF_1, _HAS_TF_2, _HAS_TORCH, _HAS_TORCH_EXPORT_API
  from coremltools.converters._profile_utils import _profile
  from coremltools.converters.mil._deployment_compatibility import AvailableTarget, check_deployment_compatibility
  from coremltools.converters.mil.converter import mil_convert
  from coremltools.converters.mil.input_types import ClassifierConfig, EnumeratedShapes, ImageType, InputType, RangeDim, Shape, TensorType
  from coremltools.converters.mil.mil import Program, types
  from coremltools.converters.mil.mil.passes.defs.quantization import ComputePrecision
  from coremltools.converters.mil.mil.passes.defs.quantization import FP16ComputePrecision
  from coremltools.converters.mil.mil.passes.graph_pass import PassOption
  from coremltools.converters.mil.mil.passes.pass_pipeline import PassPipeline
  from coremltools.models import _METADATA_SOURCE, _METADATA_SOURCE_DIALECT, _METADATA_VERSION
  from coremltools.models.utils import _MLPACKAGE_EXTENSION
label_desc: Use image node_id 5 for calling a global function with example usage: _validate_outputs_argument(outputs) and returns: None,  None, None,  None, outputs,  unknown, None,  outputs, output_names,  outputs