code: def input_explanation_data(self, list_dataset, classes):
      # List of explanations, key of explanation type is "explanation_type"
      local_explanation = self._find_first_explanation(
          ExplanationDashboardInterface.MLI_LOCAL_EXPLANATION_KEY
      )
      global_explanation = self._find_first_explanation(
          ExplanationDashboardInterface.MLI_GLOBAL_EXPLANATION_KEY
      )
      ebm_explanation = self._find_first_explanation(
          ExplanationDashboardInterface.MLI_EBM_GLOBAL_EXPLANATION_KEY
      )
  
      if local_explanation is not None:
          try:
              local_explanation["scores"] = convert_to_list(
                  local_explanation["scores"]
              )
              if np.shape(local_explanation["scores"])[-1] > 1000:
                  raise ValueError(
                      "Exceeds maximum number of features for "
                      "visualization (1000). Please regenerate"
                      " the explanation using fewer features."
                  )
              local_explanation["intercept"] = convert_to_list(
                  local_explanation["intercept"]
              )
              # We can ignore perf explanation data.
              # Note if it is added back at any point,
              # the numpy values will need to be converted to python,
              # otherwise serialization fails.
              local_explanation["perf"] = None
              self.dashboard_input[
                  ExplanationDashboardInterface.LOCAL_EXPLANATIONS
              ] = local_explanation
          except Exception as ex:
              ex_str = _format_exception(ex)
              raise ValueError(
                  "Unsupported local explanation type,"
                  "inner error: {}".format(ex_str)
              )
          if list_dataset is not None:
              row_length, feature_length = np.shape(list_dataset)
              local_dim = np.shape(local_explanation["scores"])
              if len(local_dim) != 2 and len(local_dim) != 3:
                  raise ValueError(
                      "Local explanation expected to be a 2D or 3D list"
                  )
              if len(local_dim) == 2 and (
                  local_dim[1] != feature_length
                  or local_dim[0] != row_length
              ):
                  raise ValueError(
                      "Shape mismatch: local explanation"
                      "length differs from dataset"
                  )
              if len(local_dim) == 3 and (
                  local_dim[2] != feature_length
                  or local_dim[1] != row_length
              ):
                  raise ValueError(
                      "Shape mismatch: local explanation"
                      " length differs from dataset"
                  )
              if classes is not None and len(classes) != local_dim[0]:
                  raise ValueError(
                      "Class vector length mismatch:"
                      "class names length differs from"
                      "local explanations dimension"
                  )
      if local_explanation is None and global_explanation is not None:
          try:
              global_explanation["scores"] = convert_to_list(
                  global_explanation["scores"]
              )
              if "intercept" in global_explanation:
                  global_explanation["intercept"] = convert_to_list(
                      global_explanation["intercept"]
                  )
              self.dashboard_input[
                  ExplanationDashboardInterface.GLOBAL_EXPLANATION
              ] = global_explanation
          except Exception as ex:
              ex_str = _format_exception(ex)
              raise ValueError(
                  "Unsupported global explanation type,"
                  "inner error: {}".format(ex_str)
              )
      if ebm_explanation is not None:
          try:
              self.dashboard_input[
                  ExplanationDashboardInterface.EBM_EXPLANATION
              ] = ebm_explanation
          except Exception as ex:
              ex_str = _format_exception(ex)
              raise ValueError(
                  "Unsupported ebm explanation type: {}".format(ex_str)
              )
  
imports: import traceback
  import numpy
  import pandas
  from erroranalysis._internal.constants import Metrics, display_name_to_metric, metric_to_display_name
  from erroranalysis._internal.error_analyzer import ModelAnalyzer, PredictionsAnalyzer
  from erroranalysis._internal.utils import is_spark
  from raiutils.data_processing import convert_to_list, serialize_json_safe
  from raiutils.models import is_classifier
  from responsibleai._interfaces import ErrorAnalysisData
  from .constants import ModelTask
  from .error_analysis_constants import ErrorAnalysisDashboardInterface, MethodConstants
  from .error_handling import _format_exception
  from .explanation_constants import ExplanationDashboardInterface, WidgetRequestResponseConstants
label_desc: Use image node_id 9 for calling the ErrorAnalysisDashboardInput obj's underlying member method code with example usage: obj.input_explanation_data(list_dataset, classes) without return types