class_docstr: Compare given model score to simple model score (according to given model type).
  
  Parameters
  ----------
  strategy : str, default: 'most_frequent'
      Strategy to use to generate the predictions of the simple model ['stratified', 'uniform',
      'most_frequent', 'tree'].
  
      * `stratified`: randomly draw a label based on the train set label distribution. (Previously 'random')
      * `uniform`: in regression samples predictions uniformly at random from the y ranges. in classification draws
         predictions uniformly at random from the list of values in y.
      * `most_frequent`: in regression is mean value, in classification the most common value. (Previously 'constant')
      * `tree`: runs a simple decision tree.
  scorers: Union[Mapping[str, Union[str, Callable]], List[str]], default: None
      Scorers to override the default scorers, find more about the supported formats at
      https://docs.deepchecks.com/stable/user-guide/general/metrics_guide.html
  alternative_scorers : Dict[str, Callable], default: None
      Deprecated, please use scorers instead.
  max_gain : float , default: 50
      the maximum value for the gain value, limits from both sides [-max_gain, max_gain]
  max_depth : int , default: 3
      the max depth of the tree (used only if simple model type is tree).
  n_samples : int , default: 1_000_000
      number of samples to use for this check.
  random_state : int , default: 42
      the random state (used only if simple model type is tree or random).
  
  Notes
  -----
  Scorers are a convention of sklearn to evaluate a model.
  `See scorers documentation <https://scikit-learn.org/stable/modules/model_evaluation.html#scoring>`__
  A scorer is a function which accepts (model, X, y_true) and returns a float result which is the score.
  For every scorer higher scores are better than lower scores.
  
  You can create a scorer out of existing sklearn metrics:
  
  .. code-block:: python
  
      from sklearn.metrics import roc_auc_score, make_scorer
  
      training_labels = [1, 2, 3]
      auc_scorer = make_scorer(roc_auc_score, labels=training_labels, multi_class='ovr')
      # Note that the labels parameter is required for multi-class classification in metrics like roc_auc_score or
      # log_loss that use the predict_proba function of the model, in case that not all labels are present in the test
      # set.
  
  Or you can implement your own:
  
  .. code-block:: python
  
      from sklearn.metrics import make_scorer
  
  
      def my_mse(y_true, y_pred):
          return (y_true - y_pred) ** 2
  
  
      # Mark greater_is_better=False, since scorers always suppose to return
      # value to maximize.
      my_mse_scorer = make_scorer(my_mse, greater_is_better=False)
code: def __init__(
      self,
      strategy: str = "most_frequent",
      scorers: Union[
          Mapping[str, Union[str, Callable]], List[str]
      ] = None,
      alternative_scorers: Dict[str, Callable] = None,
      max_gain: float = 50,
      max_depth: int = 3,
      n_samples: int = 1_000_000,
      random_state: int = 42,
      **kwargs,
  ):
      super().__init__(**kwargs)
      if alternative_scorers is not None:
          warnings.warn(
              f"{self.__class__.__name__}: alternative_scorers is deprecated. Please use scorers instead.",
              DeprecationWarning,
          )
          self.alternative_scorers = alternative_scorers
      else:
          self.alternative_scorers = scorers
      self.max_gain = max_gain
      self.max_depth = max_depth
      self.n_samples = n_samples
      self.random_state = random_state
      self.strategy = strategy
  
      if self.strategy not in _allowed_strategies:
          raise DeepchecksValueError(
              f"{self.__class__.__name__}: strategy {self.strategy} is not allowed. "
              f"allowed strategies are {_allowed_strategies}."
          )
  
imports: import warnings
  from collections import defaultdict
  from numbers import Number
  from typing import TYPE_CHECKING, Callable, Dict, Hashable, List, Mapping, Union
  import numpy
  import pandas
  import plotly.express
  from sklearn.dummy import DummyClassifier, DummyRegressor
  from sklearn.pipeline import Pipeline
  from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
  from deepchecks.core import CheckResult, ConditionResult
  from deepchecks.core.condition import ConditionCategory
  from deepchecks.core.errors import DeepchecksValueError
  from deepchecks.tabular import Context, Dataset, TrainTestCheck
  from deepchecks.tabular.utils.task_type import TaskType
  from deepchecks.utils.distribution.preprocessing import ScaledNumerics
  from deepchecks.utils.docref import doclink
  from deepchecks.utils.metrics import get_gain
  from deepchecks.utils.simple_models import ClassificationUniformModel, RandomModel, RegressionUniformModel
  from deepchecks.utils.strings import format_percent
label_desc: Use image node_id 1 to create a new SimpleModelComparison object from inherited base classes: TrainTestCheck with example: obj = SimpleModelComparison(strategy, scorers, alternative_scorers, max_gain, max_depth, n_samples, random_state)