class_docstr: Model used by the explainer to generate predictions.
  
  Unlike Ludwig's ECD class, this wrapper takes individual args as inputs to the forward function. We derive the order
  of these args from the order of the input_feature keys in ECD, which is guaranteed to be consistent (Python
  dictionaries are ordered consistently), so we can map back to the input feature dictionary as a second step within
  this wrapper.
code: def forward(self, *args):
      # Add back the dictionary structure so it conforms to ECD format.
      input_features: LudwigFeatureDict = self.model.input_features
      inputs = {
          # Send the input through the identity layer so that we can use the output of the layer for attribution.
          # Except for text/category features where we use the embedding layer for attribution.
          feat_name: feat_input
          if input_features.get(feat_name).type() in EMBEDDED_TYPES
          else self.input_maps.get(feat_name)(feat_input)
          for feat_name, feat_input in zip(input_features.keys(), args)
      }
  
      outputs = self.model(inputs)
  
      # At this point we only have the raw logits, but to make explainability work we need the probabilities
      # and predictions as well, so derive them.
      predictions = {}
      for of_name in self.model.output_features:
          predictions[of_name] = self.model.output_features.get(
              of_name
          ).predictions(outputs, of_name)
  
      pred_t = get_pred_col(predictions, self.target)
  
      # If the target feature is a non-scalar type (vector, set, etc.), sum it to get a scalar value.
      # https://github.com/pytorch/captum/issues/377
      if len(pred_t.shape) > 1 and self.model.output_features.get(
          self.target
      ).type() not in {
          CATEGORY,
          NUMBER,
          BINARY,
      }:
          pred_t = torch.sum(pred_t.reshape(pred_t.shape[0], -1), dim=1)
  
      return pred_t
  
imports: import copy
  import gc
  import logging
  from collections import defaultdict
  from dataclasses import dataclass
  from typing import Dict, List, Optional, Tuple
  import numpy
  import numpy.typing
  import pandas
  import torch
  from captum.attr import LayerIntegratedGradients, TokenReferenceBase
  from captum.attr._utils.input_layer_wrapper import InputIdentity
  from torch.autograd import Variable
  from tqdm import tqdm
  from ludwig.api import LudwigModel
  from ludwig.api_annotations import PublicAPI
  from ludwig.constants import BINARY, CATEGORY, DATE, IMAGE, INPUT_FEATURES, MINIMUM_BATCH_SIZE, NAME, NUMBER, PREPROCESSING, SEQUENCE, SET, TEXT, UNKNOWN_SYMBOL
  from ludwig.data.preprocessing import preprocess_for_prediction
  from ludwig.explain.explainer import Explainer
  from ludwig.explain.explanation import ExplanationsResult
  from ludwig.explain.util import get_pred_col, replace_layer_with_copy
  from ludwig.features.feature_utils import LudwigFeatureDict
  from ludwig.models.ecd import ECD
  from ludwig.utils.torch_utils import DEVICE
label_desc: Use image node_id 2 for calling the WrapperModule obj's underlying member method code with example usage: obj.forward() and returns: pred_t