OneVsRestClassifier cannot be used with TunedThresholdClassifierCV

https://github.com/scikit-learn/scikit-learn/blob/d5082d32de2797f9594c9477f2810c743560a1f1/sklearn/model_selection/_classification_threshold.py#L386

When predict is called on `OneVsRestClassifier`, it calls `predict_proba` on the underlying classifier.

If the underlying is a `TunedThresholdClassifierCV`, it redirects to the underlying estimator instead.

On the line referenced, I think that `OneVsRestClassifier` should check if the estimator is `TunedThresholdClassifierCV`, and if so use the `best_threshold_` instead of 0.5

COMMENT:
Just for completeness of this issue, this was the solution I designed and it fixed the issue.  I basicaly overwrite the `_threshold_for_binary_predict` function and ensure I get it for each underlying classifier instead.

From this class:
https://github.com/scikit-learn/scikit-learn/blob/6eeb16782ba417b2a00c436da0b83edadfcd7575/sklearn/multiclass.py#L482


My solution - as not to disturb sklean source code. 

```
# designed to support tuners too.
class CustomOneVsRestClassifier(OneVsRestClassifier):

    import array

    import scipy.sparse as sp
    from sklearn.base import is_classifier
    from sklearn.model_selection import (FixedThresholdClassifier,
                                         TunedThresholdClassifierCV)
    from sklearn.multiclass import _predict_binary
    from sklearn.utils.validation import _num_samples, check_is_fitted

    """Custom function to get the threshold from the tuner if available"""

    def _threshold_for_binary_predict(self, estimator):
        """Threshold for predictions from binary estimator."""
        # predict_proba threshold
        if (isinstance(estimator, TunedThresholdClassifierCV)):
            return estimator.best_threshold_
        elif (isinstance(estimator, FixedThresholdClassifier)):
            return estimator.threshold_
        elif hasattr(estimator, "decision_function") and is_classifier(estimator):
            return 0.0
        else:
            return 0.5

    def predict(self, X):
        """Predict multi-class targets using underlying estimators.

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            Data.

        Returns
        -------
        y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_classes)
            Predicted multi-class targets.
        """
        from sklearn.utils.validation import _num_samples, check_is_fitted
        check_is_fitted(self)

        n_samples = _num_samples(X)
        if self.label_binarizer_.y_type_ == "multiclass":
            maxima = np.empty(n_samples, dtype=float)
            maxima.fill(-np.inf)
            argmaxima = np.zeros(n_samples, dtype=int)
            for i, e in enumerate(self.estimators_):
                pred = _predict_binary(e, X)
                np.maximum(maxima, pred, out=maxima)
                argmaxima[maxima == pred] = i
            return self.classes_[argmaxima]
        else:
            indices = array.array("i")
            indptr = array.array("i", [0])
            for e in self.estimators_:
                thresh = self._threshold_for_binary_predict(e)
                indices.extend(np.where(_predict_binary(e, X) > thresh)[0])
                indptr.append(len(indices))
            data = np.ones(len(indices), dtype=int)
            indicator = sp.csc_matrix(
                (data, indices, indptr), shape=(
                    n_samples, len(self.estimators_))
            )
            return self.label_binarizer_.inverse_transform(indicator)
```

Labels: Bug, Needs Decision