code: def run_node(
      cls,
      node,
      inputs,
      device="CPU",
      opset_version=_known_opset_version,
      outputs_info=None,
  ):
      super(Caffe2Backend, cls).run_node(
          node,
          inputs,
          device=device,
          outputs_info=outputs_info,
          opset_version=opset_version,
      )
  
      value_infos = []
      device_option = get_device_option(Device(device))
      ws = Workspace()
      with core.DeviceScope(device_option):  # temporary!
          if isinstance(inputs, dict):
              for key, value in inputs.items():
                  ws.FeedBlob(key, value)
                  value_infos.append(
                      onnx.helper.make_tensor_value_info(
                          name=key,
                          elem_type=onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[
                              value.dtype
                          ],
                          shape=value.shape,
                      ).SerializeToString()
                  )
          else:
              assert len(node.input) == len(
                  inputs
              ), "{}: expected {} but got {}".format(
                  node.op_type, len(node.input), len(inputs)
              )
              for key, value in zip(node.input, inputs):
                  ws.FeedBlob(key, value)
                  value_infos.append(
                      onnx.helper.make_tensor_value_info(
                          name=key,
                          elem_type=onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[
                              value.dtype
                          ],
                          shape=value.shape,
                      ).SerializeToString()
                  )
  
          ops = []
          cbackend = C.Caffe2Backend(cls._dummy_name)
          ops_str = cbackend.convert_node(
              node.SerializeToString(), value_infos, opset_version
          )
          for s in ops_str[0] + ops_str[1]:
              op = caffe2_pb2.OperatorDef()
              op.ParseFromString(s)
              op.device_option.CopyFrom(device_option)
              ops.append(op)
          ws.RunOperatorsOnce(ops)
          output_values = [ws.FetchBlob(name) for name in node.output]
          return namedtupledict("Outputs", node.output)(*output_values)
  
imports: import collections
  import sys
  import zipfile
  import itertools
  import onnx.backend
  from caffe2.python import core, workspace, rnn_cell, gru_cell
  from caffe2.python.model_helper import ModelHelper
  from caffe2.proto import caffe2_pb2
  import caffe2.python.utils
  import numpy
  import onnx
  from onnx import TensorProto
  import onnx.numpy_helper
  import onnx.defs
  import onnx.shape_inference
  import onnx.utils
  from onnx.backend.base import Backend, Device, DeviceType, namedtupledict
  from caffe2.python.onnx.workspace import Workspace
  from caffe2.python.onnx.backend_rep import Caffe2Rep
  import caffe2.python._import_c_extension
  import warnings
label_desc: Use image node_id 2 for calling the Caffe2Backend obj's underlying member method code with example usage: obj.run_node(cls, node, inputs, device, opset_version, outputs_info) and returns: namedtupledict