class_docstr: Dummy model class used for inference with static predictions from the user.
  
  Parameters
  ----------
  train: Dataset
      Dataset, representing data an estimator was fitted on.
  test: Dataset
      Dataset, representing data an estimator predicts on.
  y_pred_train: t.Optional[np.ndarray]
      Array of the model prediction over the train dataset.
  y_pred_test: t.Optional[np.ndarray]
      Array of the model prediction over the test dataset.
  y_proba_train: np.ndarray
      Array of the model prediction probabilities over the train dataset.
  y_proba_test: np.ndarray
      Array of the model prediction probabilities over the test dataset.
  validate_data_on_predict: bool, default = True
      If true, before predicting validates that the received data samples have the same index as in original data.
code: def __init__(
      self,
      test: Dataset,
      y_proba_test: t.Optional[np.ndarray] = None,
      y_pred_test: t.Optional[np.ndarray] = None,
      train: t.Optional[Dataset] = None,
      y_pred_train: t.Optional[np.ndarray] = None,
      y_proba_train: t.Optional[np.ndarray] = None,
      validate_data_on_predict: bool = True,
      model_classes: t.Optional[t.List[t.Any]] = None,
  ):
      if train is not None and test is not None:
          # check if datasets have same indexes
          train_index = train.data.index
          test_index = test.data.index
          if set(train_index) & set(test_index):
              train.data.index = [f"train-{it}" for it in train_index]
              test.data.index = [f"test-{it}" for it in test_index]
              get_logger().warning(
                  'train and test datasets have common index - adding "train"/"test" '
                  "prefixes. To avoid that provide datasets with no common indexes "
                  "or pass the model object instead of the predictions."
              )
  
      feature_df_list = []
      predictions = []
      probas = []
  
      for dataset, y_pred, y_proba in (
          (train, y_pred_train, y_proba_train),
          (test, y_pred_test, y_proba_test),
      ):
          if y_pred is not None and not isinstance(y_pred, np.ndarray):
              y_pred = np.array(y_pred)
          if y_proba is not None and not isinstance(
              y_proba, np.ndarray
          ):
              y_proba = np.array(y_proba)
          if dataset is not None:
              feature_df_list.append(dataset.features_columns)
              if y_pred is None and y_proba is not None:
                  validate_proba(y_proba, model_classes)
                  y_pred = np.argmax(y_proba, axis=-1)
                  y_pred = np.array(model_classes)[y_pred]
              if y_pred is not None:
                  if len(y_pred.shape) > 1 and y_pred.shape[1] == 1:
                      y_pred = y_pred[:, 0]
                  ensure_predictions_shape(y_pred, dataset.data)
                  y_pred_ser = pd.Series(
                      list(y_pred), index=dataset.data.index
                  )
                  predictions.append(y_pred_ser)
                  if y_proba is not None:
                      ensure_predictions_proba(y_proba, y_pred)
                      proba_df = pd.DataFrame(data=y_proba)
                      proba_df.index = dataset.data.index
                      probas.append(proba_df)
  
      self.predictions = (
          pd.concat(predictions, axis=0) if predictions else None
      )
      self.probas = pd.concat(probas, axis=0) if probas else None
      self.feature_df_list = feature_df_list
      self.validate_data_on_predict = validate_data_on_predict
  
      if self.predictions is not None:
          self.predict = self._predict
  
      if self.probas is not None:
          self.predict_proba = self._predict_proba
  
imports: import typing
  import numpy
  import pandas
  from deepchecks.core.context import BaseContext
  from deepchecks.core.errors import DatasetValidationError, DeepchecksNotSupportedError, DeepchecksValueError, ModelValidationError
  from deepchecks.tabular._shared_docs import docstrings
  from deepchecks.tabular.dataset import Dataset
  from deepchecks.tabular.metric_utils import DeepcheckScorer, get_default_scorers, init_validate_scorers
  from deepchecks.tabular.metric_utils.scorers import validate_proba
  from deepchecks.tabular.utils.feature_importance import calculate_feature_importance_or_none, validate_feature_importance
  from deepchecks.tabular.utils.task_inference import get_all_labels, infer_classes_from_model, infer_task_type_by_class_number, infer_task_type_by_labels
  from deepchecks.tabular.utils.task_type import TaskType
  from deepchecks.tabular.utils.validation import ensure_predictions_proba, ensure_predictions_shape, model_type_validation, validate_model
  from deepchecks.utils.docref import doclink
  from deepchecks.utils.logger import get_logger
  from deepchecks.utils.plot import DEFAULT_DATASET_NAMES
  from deepchecks.utils.typing import BasicModel
label_desc: Use image node_id 1 to create a new _DummyModel object  with example: obj = _DummyModel(test, y_proba_test, y_pred_test, train, y_pred_train, y_proba_train, validate_data_on_predict, model_classes)