docs: def get_score_importances(
          score_func,  # type: Callable[[Any, Any], float]
          X,
          y,
          n_iter=5,  # type: int
          columns_to_shuffle=None,
          random_state=None
      ):
      # type: (...) -> Tuple[float, List[np.ndarray]]
      """
      Return ``(base_score, score_decreases)`` tuple with the base score and
      score decreases when a feature is not available.
  
      ``base_score`` is ``score_func(X, y)``; ``score_decreases``
      is a list of length ``n_iter`` with feature importance arrays
      (each array is of shape ``n_features``); feature importances are computed
      as score decrease when a feature is not available.
  
      ``n_iter`` iterations of the basic algorithm is done, each iteration
      starting from a different random seed.
  
      If you just want feature importances, you can take a mean of the result::
  
          import numpy as np
          from eli5.permutation_importance import get_score_importances
  
          base_score, score_decreases = get_score_importances(score_func, X, y)
          feature_importances = np.mean(score_decreases, axis=0)
  
      """
      rng = check_random_state(random_state)
      base_score = score_func(X, y)
      scores_decreases = []
      for i in range(n_iter):
          scores_shuffled = _get_scores_shufled(
              score_func, X, y, columns_to_shuffle=columns_to_shuffle,
              random_state=rng
          )
          scores_decreases.append(-scores_shuffled + base_score)
      return base_score, scores_decreases