class_docstr: Meta-estimator for parallel predict and transform.
  
  Parameters
  ----------
  estimator : Estimator
      The underlying estimator that is fit.
  
  scoring : string or callable, optional
      A single string (see :ref:`scoring_parameter`) or a callable
      (see :ref:`scoring`) to evaluate the predictions on the test set.
  
      For evaluating multiple metrics, either give a list of (unique)
      strings or a dict with names as keys and callables as values.
  
      NOTE that when using custom scorers, each scorer should return a
      single value. Metric functions returning a list/array of values
      can be wrapped into multiple scorers that return one value each.
  
      See :ref:`multimetric_grid_search` for an example.
  
      .. warning::
  
         If None, the estimator's default scorer (if available) is used.
         Most scikit-learn estimators will convert large Mars tensors to
         a single NumPy array, which may exhaust the memory of your worker.
         You probably want to always specify `scoring`.
  
  Notes
  -----
  
  .. warning::
  
     This class is not appropriate for parallel or distributed *training*
     on large datasets. For that, see :class:`Incremental`, which provides
     distributed (but sequential) training. If you're doing distributed
     hyperparameter optimization on larger-than-memory datasets, see
     :class:`mars.learn.model_selection.IncrementalSearch`.
  
  This estimator does not parallelize the training step. This simply calls
  the underlying estimators's ``fit`` method called and copies over the
  learned attributes to ``self`` afterwards.
  
  It is helpful for situations where your training dataset is relatively
  small (fits on a single machine) but you need to predict or transform
  a much larger dataset. ``predict``, ``predict_proba`` and ``transform``
  will be done in parallel (potentially distributed if you've connected
  to a Mars cluster).
  
  Note that many scikit-learn estimators already predict and transform in
  parallel. This meta-estimator may still be useful in those cases when your
  dataset is larger than memory, as the distributed scheduler will ensure the
  data isn't all read into memory at once.
  
  See Also
  --------
  Incremental
  mars.learn.model_selection.IncrementalSearch
  
  Examples
  --------
  >>> from sklearn.ensemble import GradientBoostingClassifier
  >>> from sklearn.datasets import make_classification
  >>> import mars.tensor as mt
  >>> from mars.learn.wrappers import ParallelPostFit
  
  Make a small 1,000 sample 2 training dataset and fit normally.
  
  >>> X, y = make_classification(n_samples=1000, random_state=0)
  >>> clf = ParallelPostFit(estimator=GradientBoostingClassifier(),
  ...                       scoring='accuracy')
  >>> clf.fit(X, y)
  ParallelPostFit(estimator=GradientBoostingClassifier(...))
  
  >>> clf.classes_
  array([0, 1])
  
  Transform and predict return Mars outputs for Mars inputs.
  
  >>> X_big, y_big = make_classification(n_samples=100000,
                                         random_state=0)
  >>> X_big, y_big = mt.tensor(X_big), mt.tensor(y_big)
  >>> clf.predict(X_big)
  array([1, 0, 0, ..., 1, 0, 0])
  
  Which can be computed in parallel.
  
  >>> clf.predict_proba(X_big)
  array([[0.01780031, 0.98219969],
         [0.62199242, 0.37800758],
         [0.89059934, 0.10940066],
         ...,
         [0.03249968, 0.96750032],
         [0.951434  , 0.048566  ],
         [0.99527114, 0.00472886]])
docstr: Log of probability estimates.
  
  For Mars inputs, a Mars tensor is returned. For other
  inputs (NumPy array, pandas dataframe, scipy sparse matrix), the
  regular return value is returned.
  
  If the underlying estimator does not have a ``predict_proba``
  method, then an ``AttributeError`` is raised.
  
  Parameters
  ----------
  X : array or dataframe
  
  Returns
  -------
  y : array-like
docstr_tok: ["Log","of","probability","estimates",".","For","Mars","inputs",",","a","Mars","tensor","is","returned",".","For","other","inputs","(","NumPy","array",",","pandas","dataframe",",","scipy","sparse","matrix",")",",","the","regular","return","value","is","returned",".","If","the","underlying","estimator","does","not","have","a","``","predict_proba","``","method",",","then","an","``","AttributeError","``","is","raised",".","Parameters","--","--","--","--","--","X",":","array","or","dataframe","Returns","--","--","--","-","y",":","array-like"]
code: def predict_log_proba(self, X, execute=True):
      """
      Log of probability estimates.
  
      For Mars inputs, a Mars tensor is returned. For other
      inputs (NumPy array, pandas dataframe, scipy sparse matrix), the
      regular return value is returned.
  
      If the underlying estimator does not have a ``predict_proba``
      method, then an ``AttributeError`` is raised.
  
      Parameters
      ----------
      X : array or dataframe
  
      Returns
      -------
      y : array-like
      """
  
      self._check_method("predict_log_proba")
      result = mt.log(self.predict_proba(X, execute=False))
      if execute:
          result.execute()
      return result
  
imports: from typing import Callable, Union
  import numpy
  from sklearn.base import MetaEstimatorMixin, BaseEstimator, RegressorMixin, ClassifierMixin
  from ..None import remote
  from ..None import tensor
  from .base import BaseEstimator, RegressorMixin, ClassifierMixin
  from .metrics import get_scorer
  from .utils import copy_learned_attributes, check_array
label_desc: Use image node_id 10 for calling the ParallelPostFit obj's underlying member method code with example usage: obj.predict_log_proba(X, execute) and returns: result