code: def execute(
      self,
      model: Any,
      input_data: DataManager,
      optimization_time: OptimizationTime,
      metric_drop_ths: float,
      metric: Callable,
      model_params: ModelParams,
      model_outputs: List[Tuple[Any, ...]],
      ignore_compilers: List[ModelCompiler],
      ignore_compressors: List[ModelCompressor],
      source_dl_framework: DeepLearningFramework,
      is_diffusion: bool = False,
  ) -> List[OptimizedModel]:
      self.source_dl_framework = source_dl_framework
  
      # TODO: implement and select compressors from hardware
  
      compilers = self._select_compilers_from_hardware()
  
      remove_compiler_list = []
      add_compiler_list = []
      for compiler in ignore_compilers:
          if compiler in MULTI_FRAMEWORK_COMPILERS:
              add_compiler_list += MULTI_FRAMEWORK_COMPILERS[compiler]
              remove_compiler_list.append(compiler)
  
      for c in remove_compiler_list:
          ignore_compilers.remove(c)
  
      ignore_compilers += add_compiler_list
  
      (
          self.compiler_ops,
          self.build_inference_learner_ops,
      ) = self._load_compilers(
          ignore_compilers=ignore_compilers,
          compilers=compilers,
      )
      self._optimize(
          model=model,
          input_data=input_data,
          optimization_time=optimization_time,
          metric_drop_ths=metric_drop_ths,
          metric=metric,
          model_params=model_params,
          model_outputs=model_outputs,
          ignore_compilers=ignore_compilers,
          is_diffusion=is_diffusion,
      )
  
      return self.optimized_models
  
imports: import abc
  from tempfile import TemporaryDirectory
  from typing import Any, Callable, Dict, List, Tuple, Type, Union
  from nebullvm.config import ACTIVATION_METRIC_DROP_THS
  from nebullvm.core.models import OptimizedModel, OptimizationTime, ModelParams, ModelCompiler, ModelCompressor, DeepLearningFramework, DeviceType, QuantizationType
  from nebullvm.operations.base import Operation
  from nebullvm.operations.inference_learners.base import BuildInferenceLearner
  from nebullvm.operations.inference_learners.builders import DeepSparseBuildInferenceLearner, FasterTransformerBuildInferenceLearner, IntelNeuralCompressorBuildInferenceLearner, ONNXApacheTVMBuildInferenceLearner, ONNXBuildInferenceLearner, ONNXTensorRTBuildInferenceLearner, OpenVINOBuildInferenceLearner, PyTorchApacheTVMBuildInferenceLearner, PyTorchTensorRTBuildInferenceLearner, TensorflowBuildInferenceLearner, TFLiteBuildInferenceLearner, TorchNeuronBuildInferenceLearner, TorchXLABuildInferenceLearner, TorchDynamoBuildInferenceLearner, TorchScriptBuildInferenceLearner
  from nebullvm.operations.measures.measures import MetricDropMeasure
  from nebullvm.operations.measures.utils import compute_optimized_running_time, compute_relative_difference
  from nebullvm.operations.optimizations.compilers.base import Compiler
  from nebullvm.operations.optimizations.compilers.deepsparse import DeepSparseCompiler
  from nebullvm.operations.optimizations.compilers.faster_transformer import FasterTransformerCompiler
  from nebullvm.operations.optimizations.compilers.intel_neural_compressor import IntelNeuralCompressorCompiler
  from nebullvm.operations.optimizations.compilers.onnxruntime import ONNXCompiler
  from nebullvm.operations.optimizations.compilers.openvino import OpenVINOCompiler
  from nebullvm.operations.optimizations.compilers.tensor_rt import ONNXTensorRTCompiler, PyTorchTensorRTCompiler
  from nebullvm.operations.optimizations.compilers.tensorflow import TensorflowBackendCompiler, TFLiteBackendCompiler
  from nebullvm.operations.optimizations.compilers.torch_dynamo import TorchDynamoCompiler
  from nebullvm.operations.optimizations.compilers.torch_neuron import TorchNeuronCompiler
  from nebullvm.operations.optimizations.compilers.torch_xla import TorchXLACompiler
  from nebullvm.operations.optimizations.compilers.torchscript import TorchScriptCompiler
  from nebullvm.operations.optimizations.compilers.tvm import ONNXApacheTVMCompiler, PyTorchApacheTVMCompiler
  from nebullvm.optional_modules.tensorflow import tensorflow
  from nebullvm.optional_modules.torch import torch
  from nebullvm.tools.data import DataManager
  from nebullvm.tools.transformations import MultiStageTransformation
  from nebullvm.tools.utils import get_throughput
label_desc: Use image node_id 2 for calling the Optimizer obj's underlying member method code with example usage: obj.execute(model, input_data, optimization_time, metric_drop_ths, metric, model_params, model_outputs, ignore_compilers, ignore_compressors, source_dl_framework, is_diffusion) and returns: self