docs: def explain_prediction_linear_classifier(clf, 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 linear classifier.
  
      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 classifier ``clf``
      (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
      classifier. Set it to True if you're passing ``vec``, but ``doc``
      is already vectorized.
      """
      vec, feature_names = handle_vec(clf, doc, vec, vectorized, feature_names)
      X = get_X(doc, vec=vec, vectorized=vectorized, to_dense=True)
  
      proba = predict_proba(clf, X)
      score, = clf.decision_function(X)
  
      if has_intercept(clf):
          X = add_intercept(X)
      x = get_X0(X)
  
      feature_names, flt_indices = feature_names.handle_filter(
          feature_filter, feature_re, x)
  
      res = Explanation(
          estimator=repr(clf),
          method='linear model',
          targets=[],
      )
      assert res.targets is not None
  
      _weights = _linear_weights(clf, x, top, feature_names, flt_indices)
      classes = getattr(clf, "classes_", ["-1", "1"])  # OneClassSVM support
      display_names = get_target_display_names(classes, target_names,
                                               targets, top_targets, score)
  
      if is_multiclass_classifier(clf):
          for label_id, label in display_names:
              target_expl = TargetExplanation(
                  target=label,
                  feature_weights=_weights(label_id),
                  score=score[label_id],
                  proba=proba[label_id] if proba is not None else None,
              )
              add_weighted_spans(doc, vec, vectorized, target_expl)
              res.targets.append(target_expl)
      else:
          if len(display_names) == 1:  # target is passed explicitly
              label_id, target = display_names[0]
          else:
              label_id = 1 if score >= 0 else 0
              target = display_names[label_id][1]
          scale = -1 if label_id == 0 else 1
  
          target_expl = TargetExplanation(
              target=target,
              feature_weights=_weights(0, scale=scale),
              score=score,
              proba=proba[label_id] if proba is not None else None,
          )
          add_weighted_spans(doc, vec, vectorized, target_expl)
          res.targets.append(target_expl)
  
      return res