class_docstr: Summarize given model performance on the train and test datasets based on selected scorers.
  
  Parameters
  ----------
  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
  n_samples : int , default: 1_000_000
      number of samples to use for this check.
  random_state : int, default: 42
      random seed for all check internals.
  
  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)
docstr: Run check.
docstr_tok: ["Run","check","."]
code: def run_logic(self, context: Context) -> CheckResult:
      """Run check."""
      train_dataset = context.train.sample(
          self.n_samples, random_state=self.random_state
      )
      test_dataset = context.test.sample(
          self.n_samples, random_state=self.random_state
      )
      model = context.model
      scorers = context.get_scorers(
          self.scorers, use_avg_defaults=False
      )
      datasets = {"Train": train_dataset, "Test": test_dataset}
  
      results = []
      for dataset_name, dataset in datasets.items():
          label = cast(pd.Series, dataset.label_col)
          n_samples_per_class = label.groupby(label).count()
          for scorer in scorers:
              scorer_value = scorer(model, dataset)
              if isinstance(scorer_value, Number):
                  results.append(
                      [
                          dataset_name,
                          pd.NA,
                          scorer.name,
                          scorer_value,
                          len(label),
                      ]
                  )
              else:
                  results.extend(
                      [
                          [
                              dataset_name,
                              class_name,
                              scorer.name,
                              class_score,
                              n_samples_per_class.get(class_name, 0),
                          ]
                          for class_name, class_score in scorer_value.items()
                      ]
                  )
  
      results_df = pd.DataFrame(
          results,
          columns=[
              "Dataset",
              "Class",
              "Metric",
              "Value",
              "Number of samples",
          ],
      )
  
      if context.with_display:
          figs = self._prepare_display(
              results_df,
              train_dataset.name or "Train",
              test_dataset.name or "Test",
          )
      else:
          figs = None
  
      return CheckResult(
          results_df, header="Train Test Performance", display=figs
      )
  
file_path: deepchecks/deepchecks/tabular/checks/model_evaluation/train_test_performance.py
imports: from numbers import Number
  from typing import Callable, List, Mapping, TypeVar, Union, cast
  import pandas
  from deepchecks.core import CheckResult
  from deepchecks.core.checks import CheckConfig
  from deepchecks.tabular import Context, TrainTestCheck
  from deepchecks.utils.abstracts.train_test_performace import TrainTestPerformanceAbstract
  from deepchecks.utils.docref import doclink
label_desc: Use image node_id 2 for calling the TrainTestPerformance obj's underlying member method code with example usage: obj.run_logic(context) and returns: CheckResult