docs: def explain_prediction_tree_regressor(
          reg, doc,
          vec=None,
          top=None,
          top_targets=None,
          target_names=None,
          targets=None,
          feature_names=None,
          feature_re=None,
          feature_filter=None,
          vectorized=False):
      """ Explain prediction of a tree regressor.
  
      See :func:`eli5.explain_prediction` for description of
      ``top``, ``top_targets``, ``target_names``, ``targets``,
      ``feature_names``, ``feature_re`` and ``feature_filter`` parameters.
  
      ``vec`` is a vectorizer instance used to transform
      raw features to the input of the regressor ``reg``
      (e.g. a fitted CountVectorizer instance); you can pass it
      instead of ``feature_names``.
  
      ``vectorized`` is a flag which tells eli5 if ``doc`` should be
      passed through ``vec`` or not. By default it is False, meaning that
      if ``vec`` is not None, ``vec.transform([doc])`` is passed to the
      regressor. Set it to True if you're passing ``vec``,
      but ``doc`` is already vectorized.
  
      Method for determining feature importances follows an idea from
      http://blog.datadive.net/interpreting-random-forests/.
      Feature weights are calculated by following decision paths in trees
      of an ensemble (or a single tree for DecisionTreeRegressor).
      Each node of the tree has an output score, and contribution of a feature
      on the decision path is how much the score changes from parent to child.
      Weights of all features sum to the output score of the estimator.
      """
      vec, feature_names = handle_vec(reg, doc, vec, vectorized, feature_names)
      X = get_X(doc, vec=vec, vectorized=vectorized)
      if feature_names.bias_name is None:
          # Tree estimators do not have an intercept, but here we interpret
          # them as having an intercept
          feature_names.bias_name = '<BIAS>'
  
      score, = reg.predict(X)
      num_targets = getattr(reg, 'n_outputs_', 1)
      is_multitarget = num_targets > 1
      feature_weights = _trees_feature_weights(reg, X, feature_names, num_targets)
      x = get_X0(add_intercept(X))
      flt_feature_names, flt_indices = feature_names.handle_filter(
          feature_filter, feature_re, x)
  
      def _weights(label_id, scale=1.0):
          weights = feature_weights[:, label_id]
          return get_top_features_filtered(x, flt_feature_names, flt_indices,
                                           weights, top, scale)
  
      res = Explanation(
          estimator=repr(reg),
          method='decision path',
          description=(DESCRIPTION_TREE_REG_MULTITARGET if is_multitarget
                       else DESCRIPTION_TREE_REG),
          targets=[],
          is_regression=True,
      )
      assert res.targets is not None
  
      names = get_default_target_names(reg, num_targets=num_targets)
      display_names = get_target_display_names(names, target_names, targets,
                                               top_targets, score)
  
      if is_multitarget:
          for label_id, label in display_names:
              target_expl = TargetExplanation(
                  target=label,
                  feature_weights=_weights(label_id),
                  score=score[label_id],
              )
              add_weighted_spans(doc, vec, vectorized, target_expl)
              res.targets.append(target_expl)
      else:
          target_expl = TargetExplanation(
              target=display_names[0][1],
              feature_weights=_weights(0),
              score=score,
          )
          add_weighted_spans(doc, vec, vectorized, target_expl)
          res.targets.append(target_expl)
  
      return res