pybear-dask 0.2.0__py3-none-any.whl

pybear_dask/model_selection/GSTCV/_GSTCVDask/_fit/_parallelized_train_scorer.py

@@ -0,0 +1,226 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from typing_extensions import Union
+from pybear.model_selection.GSTCV._type_aliases import (
+    ScorerWIPType,
+    ClassifierProtocol,
+    MaskedHolderType,
+    NDArrayHolderType
+)
+from .._type_aliases import (
+    DaskXType,
+    DaskYType
+)
+
+import numbers
+import time
+
+import numpy as np
+
+from pybear.model_selection.GSTCV._GSTCVMixin._validation._predict_proba import _val_predict_proba
+
+
+
+def _parallelized_train_scorer(
+    _X_train: DaskXType,
+    _y_train: DaskYType,
+    _FIT_OUTPUT_TUPLE: tuple[ClassifierProtocol, float, bool],
+    _f_idx: int,
+    _SCORER_DICT: ScorerWIPType,
+    _BEST_THRESHOLDS_BY_SCORER: NDArrayHolderType,
+    _error_score: Union[numbers.Real, None],
+    _verbose: int
+) -> MaskedHolderType:
+
+    # dont adjust the spacing, is congruent with test scorer
+
+    """Using the estimators fit on each train fold, use `predict_proba`
+    and _X_trains to generate _y_preds and score against the corresponding
+    _y_trains using all of the scorers.
+
+    Fill one layer of the TRAIN_FOLD_x_SCORER__SCORE.
+
+    Parameters
+    ----------
+    _X_train : DaskXType
+        A train partition of the data that was fit.
+    _y_train : DaskYType
+        The corresponding train partition of the target for the X train
+        partition.
+    _FIT_OUTPUT_TUPLE : tuple[ClassifierProtocol, float, bool]
+        A tuple holding the fitted estimator, the fit time (not needed
+        here), and the fit_excepted boolean (needed here.)
+    _f_idx : int
+        The zero-based split index of the train partition used here;
+        parallelism occurs over the different splits.
+    _SCORER_DICT : ScorerWIPType
+        A dictionary with scorer name as keys and the scorer callables
+        as values. The scorer callables are scoring metrics (or similar),
+        not make_scorer.
+    _BEST_THRESHOLDS_BY_SCORER : NDArrayHolderType:
+        After all of the fold / threshold / scorer combinations are
+        scored, the folds are averaged and the threshold with the maximum
+        score for each scorer is found. This vector has length n_scorers
+        and in each position holds a float indicating the threshold
+        value that is the best threshold for that scorer.
+    _error_score : Union[numbers.Real, Literal['raise']]
+        If this training fold excepted during fitting and `error_score`
+        was set to the 'raise' literal, this module cannot be reached.
+        Otherwise, a number or number-like was passed to `error_score`.
+        If 'fit_excepted' is True, this module puts the `error_score`
+        value in every position of the TRAIN_SCORER__SCORE_LAYER vector.
+        If `error_score` is set to np.nan, that layer is also masked.
+    _verbose : int
+        A number from 0 to 10 that indicates the amount of information
+        to display to the screen during the grid search process. 0 means
+        no output, 10 means maximum output.
+
+    Returns
+    -------
+    TRAIN_SCORER__SCORE_LAYER : MaskedHolderType
+        Masked array of shape (n_scorers, ). The score for this fold of
+        train data using every scorer and the best threshold associated
+        with that scorer.
+
+
+
+
+
+
+
+
+
+
+    """
+
+    # validation ** * ** * ** * ** * ** * ** * ** * ** * ** * ** * ** *
+    assert isinstance(_FIT_OUTPUT_TUPLE, tuple)
+    assert isinstance(_f_idx, int)
+    assert isinstance(_SCORER_DICT, dict)
+    assert all(map(callable, _SCORER_DICT.values()))
+    assert isinstance(_BEST_THRESHOLDS_BY_SCORER, np.ndarray)
+    assert isinstance(_verbose, (int, float))
+    # END validation ** * ** * ** * ** * ** * ** * ** * ** * ** * ** * *
+
+    if _verbose >= 5:
+        print(f"Start scoring fold {_f_idx + 1} train with different scorers")
+
+
+    _estimator_, _fit_time, _fit_excepted = _FIT_OUTPUT_TUPLE
+
+    TRAIN_SCORER__SCORE_LAYER: MaskedHolderType = \
+        np.ma.zeros(len(_SCORER_DICT), dtype=np.float64)
+    TRAIN_SCORER__SCORE_LAYER.mask = True
+
+
+
+
+
+
+    # IF A FOLD EXCEPTED DURING FIT, PUT IN error_score.
+    # IF error_score==np.nan, ALSO MASK THIS LAYER
+    if _fit_excepted:
+        TRAIN_SCORER__SCORE_LAYER[:] = _error_score
+        if _error_score is np.nan:
+            TRAIN_SCORER__SCORE_LAYER[:] = np.ma.masked
+
+
+
+
+        if _verbose >= 5:
+            print(f'fold {_f_idx + 1} excepted during fit, unable to score')
+
+        return TRAIN_SCORER__SCORE_LAYER
+
+
+    # v v v only accessible if fit() did not except v v v
+
+    _X_train = _X_train.persist()
+    _y_train = _y_train.persist()
+
+    pp0_time = time.perf_counter()
+    _predict_proba = _estimator_.predict_proba(_X_train)[:, -1].ravel()
+    _val_predict_proba(
+        _predict_proba,
+        _X_train.shape[0] if hasattr(_X_train, 'shape') else len(_X_train)
+    )
+    pp_time = time.perf_counter() - pp0_time
+    del pp0_time
+
+    if _verbose >= 5:
+        print(f'fold {_f_idx + 1} train predict_proba time = {pp_time: ,.3g} s')
+    del pp_time
+
+    # GET SCORES FOR ALL SCORERS #######################################
+
+    _train_fold_score_t0 = time.perf_counter()
+
+
+
+
+
+
+
+
+
+
+    for s_idx, scorer_key in enumerate(_SCORER_DICT):
+
+        _y_pred_t0 = time.perf_counter()
+        _y_train_pred = (_predict_proba >= _BEST_THRESHOLDS_BY_SCORER[s_idx])
+        _ypt = time.perf_counter() - _y_pred_t0
+        del _y_pred_t0
+        if _verbose == 10:
+            print(f"fold {_f_idx+1} train thresholding time = {_ypt: ,.3g} s")
+        del _ypt
+
+        train_scorer_t0 = time.perf_counter()
+        _score = _SCORER_DICT[scorer_key](_y_train, _y_train_pred)
+        train_scorer_score_time = time.perf_counter() - train_scorer_t0
+        del train_scorer_t0
+
+
+        TRAIN_SCORER__SCORE_LAYER[s_idx] = _score
+
+        if _verbose >= 8:
+            print(f"fold {_f_idx+1} '{scorer_key}' train score time = "
+                  f"{train_scorer_score_time: ,.3g} s")
+
+        del _score, train_scorer_score_time
+
+
+    tfst = time.perf_counter() - _train_fold_score_t0
+    del _train_fold_score_t0
+
+    # END GET SCORE FOR ALL SCORERS ####################################
+
+    if _verbose >= 5:
+        print(f'End scoring fold {_f_idx + 1} train with different scorers')
+
+        _ = _f_idx + 1
+
+        print(f'fold {_} total train thresh & score wall time = {tfst: ,.3g} s')
+        _ast = tfst / len(_SCORER_DICT)
+        print(f'fold {_} avg train thresh & score wall time = {_ast: ,.3g} s')
+        del _ast
+
+
+
+
+
+
+    del _X_train, _y_train, _predict_proba, _y_train_pred, tfst
+
+
+    return TRAIN_SCORER__SCORE_LAYER
+
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_param_conditioning/__init__.py

@@ -0,0 +1,5 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#

pybear_dask/model_selection/GSTCV/_GSTCVDask/_param_conditioning/_scheduler.py

@@ -0,0 +1,88 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from typing_extensions import Union
+from .._type_aliases import DaskSchedulerType
+
+import contextlib
+import numbers
+
+from distributed import (
+    Client,
+    get_client
+)
+
+
+
+def _cond_scheduler(
+    _scheduler: Union[DaskSchedulerType, None],
+    _n_jobs: Union[numbers.Integral, None]
+) -> DaskSchedulerType:
+    """Set the dask scheduler.
+
+    The passed scheduler supersedes all other external schedulers. If
+    "None" was passed to the scheduler kwarg of GSTCVDask (the default),
+    look for an external context manager or global scheduler using
+    `get_client`. If one exists, use nullcontext as an internal context
+    manager to not interfere with the external scheduler. If "None" was
+    passed to the scheduler kwarg of `GSTCVDask` and there is no external
+    scheduler, instantiate `distributed.Client`, which defaults to
+    `LocalCluster`, with `n_workers`=`n_jobs` and 1 thread per worker.
+    If `n_jobs` is None, uses the default `distributed.Client` behavior
+    when `n_workers` is set to None.
+
+    If a scheduler is passed, this module does not perform any validation
+    but allows that to be handled by dask at compute time.
+
+    This module intentionally deviates from the dask_ml API, and
+    disallows any shorthand methods for setting up a scheduler (such
+    as strings like 'threading' and 'multiprocessing', which are
+    ultimately passed to dask.base.get_scheduler.) All of these types
+    of configurations should be handled by the user external to the
+    `GSTCVDask` module. As much as possible, dask and distributed
+    objects are allowed to flow through without any hard-coded input.
+
+    Parameters
+    ----------
+    _scheduler : Union[SchedulerType, None]
+        _scheduler to be validated and used for compute
+
+    Returns
+    -------
+    _scheduler : DaskSchedulerType
+        Validated, instantiated scheduler
+
+    """
+
+
+    if _scheduler is None:
+    # if there is no hard scheduler...
+        try:
+            # ...try to get an existing client...
+            get_client()
+            # if a client is available (either an external context manager
+            # or a default scheduler in an outer scope) let that scheduler
+            # take precedence. set _scheduler to nullcontext for empty
+            # internal context managers.
+            _scheduler = contextlib.nullcontext()
+        except ValueError:
+            # ...if no external client and no hard scheduler (client),
+            # create a new one
+            _scheduler = Client(n_workers=_n_jobs, threads_per_worker=1)
+
+    else:
+    # if there is a hard scheduler, that supersedes all.
+        pass
+
+
+    return _scheduler
+
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_type_aliases.py

@@ -0,0 +1,43 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from typing import (
+    ContextManager,
+    Iterable,
+    Sequence
+)
+from typing_extensions import (
+    TypeAlias,
+    Union
+)
+
+import numbers
+
+import dask
+import distributed
+
+
+
+DaskXType: TypeAlias = Iterable
+DaskYType: TypeAlias = Union[Sequence[numbers.Integral], None]
+
+DaskSlicerType: TypeAlias = dask.array.core.Array
+
+DaskKFoldType: TypeAlias = tuple[DaskSlicerType, DaskSlicerType]
+
+DaskSplitType: TypeAlias = tuple[DaskXType, DaskYType]
+
+DaskSchedulerType: TypeAlias = Union[
+    distributed.scheduler.Scheduler,
+    distributed.client.Client,
+    ContextManager  # nullcontext
+]
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/__init__.py

@@ -0,0 +1,5 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/_cache_cv.py

@@ -0,0 +1,37 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+def _val_cache_cv(
+    _cache_cv: bool
+) -> None:
+    """Validate `cache_cv`.
+
+    `cache_cv` can only be boolean. Indicates if the train/test folds
+    are to be stored once first generated, or if the folds are generated
+    from X and y with the KFold indices at each point of use.
+
+    Parameters
+    ----------
+    _cache_cv : bool
+        To be validated
+
+    Returns
+    -------
+    None
+
+    """
+
+
+    if not isinstance(_cache_cv, bool):
+        raise TypeError(f"'cache_cv' must be a bool")
+
+
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/_dask_estimator.py

@@ -0,0 +1,84 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from pybear.model_selection.GSTCV._type_aliases import ClassifierProtocol
+
+import sys
+import warnings
+
+from sklearn.pipeline import Pipeline
+
+
+
+def _val_dask_estimator(
+    _estimator: ClassifierProtocol
+) -> None:
+    """Warn if the estimator is not a dask classifier, either from dask
+    itself, or from XGBoost or LightGBM.
+
+    The `GSTCVDask` module is expected to most likely encounter dask_ml,
+    xgboost, and lightgbm dask estimators. The estimator must be passed
+    as an instance, not the class itself.
+
+    Parameters
+    ----------
+    _estimator : ClassifierProtocol
+        the estimator to be validated
+
+    Returns
+    -------
+    None
+
+    """
+
+
+    # validate estimator ** * ** * ** * ** * ** * ** * ** * ** * ** * **
+
+    def get_inner_most_estimator(__estimator):
+
+        try:
+            if isinstance(__estimator, Pipeline):
+                return get_inner_most_estimator(__estimator.steps[-1][-1])
+            else:
+                return get_inner_most_estimator(__estimator.estimator)
+        except:
+            return __estimator
+
+
+    __estimator = get_inner_most_estimator(_estimator)
+
+    try:
+        _module = sys.modules[__estimator.__class__.__module__].__file__
+    except:
+        raise AttributeError(f"'{__estimator.__class__.__name__}' is not "
+            f"a valid classifier")
+
+    # 24_08_04 change raise to warn
+    # to allow XGBClassifier, reference errors associated with
+    # DaskXGBClassifier and dask GridSearch CV
+    # 25_06_28 no longer checking for non-dask estimator
+    # __ = str(_module).lower()
+    # if 'dask_ml' not in __:
+    #     warnings.warn(f"'{__estimator.__class__.__name__}' does not "
+    #         f"appear to be a dask classifier.")
+    # if 'dask' not in __ and 'conftest' not in __:  # allow pytest with
+    # mock clf
+        # raise TypeError(f"'{__estimator.__class__.__name__}' is not a
+        #     f"dask classifier. GSTCVDask can only accept dask classifiers. "
+        #     f"\nTo use non-dask classifiers, use the GSTCV package.")
+
+    del get_inner_most_estimator, __estimator, _module
+
+    # END validate estimator ** * ** * ** * ** * ** * ** * ** * ** * **
+
+
+
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/_iid.py

@@ -0,0 +1,38 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+def _val_iid(
+    _iid: bool
+) -> None:
+    """Validate `iid`.
+
+    `iid` can only be boolean. Indicates whether the data is believed to
+    have random distribution of examples (True) or if the data is
+    organized non-randomly in some way (False).
+
+    Parameters
+    ----------
+    _iid : bool
+        To be validated.
+
+    Returns
+    -------
+    None
+
+    """
+
+
+    if not isinstance(_iid, bool):
+        raise TypeError(f"'iid' must be a bool")
+
+
+
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/_validation.py

@@ -0,0 +1,54 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from pybear.model_selection.GSTCV._type_aliases import ClassifierProtocol
+
+from ....GSTCV._GSTCVDask._validation._dask_estimator import _val_dask_estimator
+from ....GSTCV._GSTCVDask._validation._cache_cv import _val_cache_cv
+from ....GSTCV._GSTCVDask._validation._iid import _val_iid
+
+
+
+def _validation(
+    _estimator: ClassifierProtocol,
+    _iid: bool,
+    _cache_cv: bool
+) -> None:
+    """Centralized hub for `GSTCVDask` parameter validation.
+
+    See the submodules for more information.
+
+    Parameters
+    ----------
+    _estimator : ClassifierProtocol
+        The estimator passed to `GSTCVDask`.
+    _iid : bool
+        Whether the data is randomly distributed along the example axis
+        or is organized in some non-random way.
+    _cache_cv : bool
+        Indicates if the train/test folds of the data are to be stored
+        when first generated, or if the folds are generated from X, y
+        and the KFold indices at each point of need. Caching all the
+        folds for each split of the data is memory-intensive.
+
+    Returns
+    -------
+    None
+
+    """
+
+
+    _val_dask_estimator(_estimator)
+
+    _val_iid(_iid)
+
+    _val_cache_cv(_cache_cv)
+
+
+
+

pybear_dask/model_selection/GSTCV/_GSTCVDask/_validation/_y.py

@@ -0,0 +1,91 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#
+
+
+
+from typing import Iterable
+
+import numbers
+
+import numpy as np
+from dask import compute
+import dask.array as da
+import dask.dataframe as ddf
+
+
+
+def _val_y(
+    _y: Iterable[numbers.Integral]  # not DaskYType... see the notes.
+) -> None:
+    """Validate `_y`.
+
+    `_y` must be single label and binary in [0, 1].
+
+    The validation is considerably looser than what would be for
+    DaskYType. This allows *any* 1D container holding 0's and 1's.
+    Let the estimator raise an error if there is a problem with the
+    container.
+
+    Parameters
+    ----------
+    _y : vector-like of shape (n_samples,) or (n_samples, 1)
+        The target for the data.
+
+    Returns
+    -------
+    None
+
+    """
+
+
+    # y ** * ** * ** * ** * ** * ** * ** * ** * ** * ** * ** * ** * ** *
+
+    if hasattr(_y, 'shape'):
+        if hasattr(_y, 'compute'):
+            y_shape = compute(*_y.shape)
+        else:
+            y_shape = _y.shape
+    else:
+        try:
+            y_shape = np.array(_y).shape
+            if isinstance(_y, set):
+                y_shape = np.array(list(_y)).shape
+        except:
+            raise TypeError(f"'y' must have a 'shape' attribute.")
+
+
+    _err_msg = (
+        f"GSTCVDask can only perform thresholding on vector-like binary "
+        f"targets with values in [0,1]. \nPass 'y' as a vector of 0's and 1's."
+    )
+
+    if len(y_shape) == 1:
+        pass
+    elif len(y_shape) == 2:
+        if y_shape[1] != 1:
+            raise ValueError(_err_msg)
+    else:
+        raise ValueError(_err_msg)
+
+
+    if isinstance(_y, da.core.Array):
+        _unique = set(da.unique(_y).compute())
+    elif isinstance(_y, (ddf.DataFrame, ddf.Series)):
+        _unique = set(da.unique(_y.to_dask_array(lengths=True)).compute())
+    elif hasattr(_y, 'shape'):
+        _unique = set(np.unique(_y))
+    else:
+        _unique = set(np.unique(list(_y)))
+
+
+    if not _unique.issubset({0, 1}):
+        raise ValueError(_err_msg)
+
+    del _unique
+
+
+
+

pybear_dask/model_selection/GSTCV/__init__.py

@@ -0,0 +1,5 @@
+# Author:
+#         Bill Sousa
+#
+# License: BSD 3 clause
+#