unifiedbooster 0.9.0__py3-none-any.whl

unifiedbooster/nonconformist/acp.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python
+
+"""
+Aggregated conformal predictors
+"""
+
+# Authors: Henrik Linusson
+
+import numpy as np
+from sklearn.model_selection import KFold, StratifiedKFold
+from sklearn.model_selection import ShuffleSplit, StratifiedShuffleSplit
+from sklearn.base import clone
+from nonconformist.base import BaseEstimator
+from nonconformist.util import calc_p
+
+
+# -----------------------------------------------------------------------------
+# Sampling strategies
+# -----------------------------------------------------------------------------
+class BootstrapSampler(object):
+    """Bootstrap sampler.
+
+    See also
+    --------
+    CrossSampler, RandomSubSampler
+
+    Examples
+    --------
+    """
+
+    def gen_samples(self, y, n_samples, problem_type):
+        for i in range(n_samples):
+            idx = np.array(range(y.size))
+            train = np.random.choice(y.size, y.size, replace=True)
+            cal_mask = np.array(np.ones(idx.size), dtype=bool)
+            for j in train:
+                cal_mask[j] = False
+            cal = idx[cal_mask]
+
+            yield train, cal
+
+
+class CrossSampler(object):
+    """Cross-fold sampler.
+
+    See also
+    --------
+    BootstrapSampler, RandomSubSampler
+
+    Examples
+    --------
+    """
+
+    def gen_samples(self, y, n_samples, problem_type):
+        if problem_type == "classification":
+            folds = StratifiedKFold(y, n_folds=n_samples)
+        else:
+            folds = KFold(y.size, n_folds=n_samples)
+        for train, cal in folds:
+            yield train, cal
+
+
+class RandomSubSampler(object):
+    """Random subsample sampler.
+
+    Parameters
+    ----------
+    calibration_portion : float
+            Ratio (0-1) of examples to use for calibration.
+
+    See also
+    --------
+    BootstrapSampler, CrossSampler
+
+    Examples
+    --------
+    """
+
+    def __init__(self, calibration_portion=0.3):
+        self.cal_portion = calibration_portion
+
+    def gen_samples(self, y, n_samples, problem_type):
+        if problem_type == "classification":
+            splits = StratifiedShuffleSplit(
+                y, n_iter=n_samples, test_size=self.cal_portion
+            )
+        else:
+            splits = ShuffleSplit(
+                y.size, n_iter=n_samples, test_size=self.cal_portion
+            )
+
+        for train, cal in splits:
+            yield train, cal
+
+
+# -----------------------------------------------------------------------------
+# Conformal ensemble
+# -----------------------------------------------------------------------------
+class AggregatedCp(BaseEstimator):
+    """Aggregated conformal predictor.
+
+    Combines multiple IcpClassifier or IcpRegressor predictors into an
+    aggregated model.
+
+    Parameters
+    ----------
+    predictor : object
+            Prototype conformal predictor (e.g. IcpClassifier or IcpRegressor)
+            used for defining conformal predictors included in the aggregate model.
+
+    sampler : object
+            Sampler object used to generate training and calibration examples
+            for the underlying conformal predictors.
+
+    aggregation_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors. Defaults to ``numpy.mean``.
+
+    n_models : int
+            Number of models to aggregate.
+
+    Attributes
+    ----------
+    predictor : object
+            Prototype conformal predictor.
+
+    predictors : list
+            List of underlying conformal predictors.
+
+    sampler : object
+            Sampler object used to generate training and calibration examples.
+
+    agg_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors
+
+    References
+    ----------
+    .. [1] Vovk, V. (2013). Cross-conformal predictors. Annals of Mathematics
+            and Artificial Intelligence, 1-20.
+
+    .. [2] Carlsson, L., Eklund, M., & Norinder, U. (2014). Aggregated
+            Conformal Prediction. In Artificial Intelligence Applications and
+            Innovations (pp. 231-240). Springer Berlin Heidelberg.
+
+    Examples
+    --------
+    """
+
+    def __init__(
+        self,
+        predictor,
+        sampler=BootstrapSampler(),
+        aggregation_func=None,
+        n_models=10,
+    ):
+        self.predictors = []
+        self.n_models = n_models
+        self.predictor = predictor
+        self.sampler = sampler
+
+        if aggregation_func is not None:
+            self.agg_func = aggregation_func
+        else:
+            self.agg_func = lambda x: np.mean(x, axis=2)
+
+    def fit(self, x, y):
+        """Fit underlying conformal predictors.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of examples for fitting the underlying conformal predictors.
+
+        y : numpy array of shape [n_samples]
+                Outputs of examples for fitting the underlying conformal predictors.
+
+        Returns
+        -------
+        None
+        """
+        self.n_train = y.size
+        self.predictors = []
+        idx = np.random.permutation(y.size)
+        x, y = x[idx, :], y[idx]
+        problem_type = self.predictor.__class__.get_problem_type()
+        samples = self.sampler.gen_samples(y, self.n_models, problem_type)
+        for train, cal in samples:
+            predictor = clone(self.predictor)
+            predictor.fit(x[train, :], y[train])
+            predictor.calibrate(x[cal, :], y[cal])
+            self.predictors.append(predictor)
+
+        if problem_type == "classification":
+            self.classes = self.predictors[0].classes
+
+    def predict(self, x, significance=None):
+        """Predict the output values for a set of input patterns.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of patters for which to predict output values.
+
+        significance : float or None
+                Significance level (maximum allowed error rate) of predictions.
+                Should be a float between 0 and 1. If ``None``, then the p-values
+                are output rather than the predictions. Note: ``significance=None``
+                is applicable to classification problems only.
+
+        Returns
+        -------
+        p : numpy array of shape [n_samples, n_classes] or [n_samples, 2]
+                For classification problems: If significance is ``None``, then p
+                contains the p-values for each sample-class pair; if significance
+                is a float between 0 and 1, then p is a boolean array denoting
+                which labels are included in the prediction sets.
+
+                For regression problems: Prediction interval (minimum and maximum
+                boundaries) for the set of test patterns.
+        """
+        is_regression = (
+            self.predictor.__class__.get_problem_type() == "regression"
+        )
+
+        n_examples = x.shape[0]
+
+        if is_regression and significance is None:
+            signs = np.arange(0.01, 1.0, 0.01)
+            pred = np.zeros((n_examples, 2, signs.size))
+            for i, s in enumerate(signs):
+                predictions = np.dstack(
+                    [p.predict(x, s) for p in self.predictors]
+                )
+                predictions = self.agg_func(predictions)
+                pred[:, :, i] = predictions
+            return pred
+        else:
+
+            def f(p, x):
+                return p.predict(x, significance if is_regression else None)
+
+            predictions = np.dstack([f(p, x) for p in self.predictors])
+            predictions = self.agg_func(predictions)
+
+            if significance and not is_regression:
+                return predictions >= significance
+            else:
+                return predictions
+
+
+class CrossConformalClassifier(AggregatedCp):
+    """Cross-conformal classifier.
+
+    Combines multiple IcpClassifiers into a cross-conformal classifier.
+
+    Parameters
+    ----------
+    predictor : object
+            Prototype conformal predictor (e.g. IcpClassifier or IcpRegressor)
+            used for defining conformal predictors included in the aggregate model.
+
+    aggregation_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors. Defaults to ``numpy.mean``.
+
+    n_models : int
+            Number of models to aggregate.
+
+    Attributes
+    ----------
+    predictor : object
+            Prototype conformal predictor.
+
+    predictors : list
+            List of underlying conformal predictors.
+
+    sampler : object
+            Sampler object used to generate training and calibration examples.
+
+    agg_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors
+
+    References
+    ----------
+    .. [1] Vovk, V. (2013). Cross-conformal predictors. Annals of Mathematics
+            and Artificial Intelligence, 1-20.
+
+    Examples
+    --------
+    """
+
+    def __init__(self, predictor, n_models=10):
+        super(CrossConformalClassifier, self).__init__(
+            predictor, CrossSampler(), n_models
+        )
+
+    def predict(self, x, significance=None):
+        ncal_ngt_neq = np.stack(
+            [p._get_stats(x) for p in self.predictors], axis=3
+        )
+        ncal_ngt_neq = ncal_ngt_neq.sum(axis=3)
+
+        p = calc_p(
+            ncal_ngt_neq[:, :, 0],
+            ncal_ngt_neq[:, :, 1],
+            ncal_ngt_neq[:, :, 2],
+            smoothing=self.predictors[0].smoothing,
+        )
+
+        if significance:
+            return p > significance
+        else:
+            return p
+
+
+class BootstrapConformalClassifier(AggregatedCp):
+    """Bootstrap conformal classifier.
+
+    Combines multiple IcpClassifiers into a bootstrap conformal classifier.
+
+    Parameters
+    ----------
+    predictor : object
+            Prototype conformal predictor (e.g. IcpClassifier or IcpRegressor)
+            used for defining conformal predictors included in the aggregate model.
+
+    aggregation_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors. Defaults to ``numpy.mean``.
+
+    n_models : int
+            Number of models to aggregate.
+
+    Attributes
+    ----------
+    predictor : object
+            Prototype conformal predictor.
+
+    predictors : list
+            List of underlying conformal predictors.
+
+    sampler : object
+            Sampler object used to generate training and calibration examples.
+
+    agg_func : callable
+            Function used to aggregate the predictions of the underlying
+            conformal predictors
+
+    References
+    ----------
+    .. [1] Vovk, V. (2013). Cross-conformal predictors. Annals of Mathematics
+            and Artificial Intelligence, 1-20.
+
+    Examples
+    --------
+    """
+
+    def __init__(self, predictor, n_models=10):
+        super(BootstrapConformalClassifier, self).__init__(
+            predictor, BootstrapSampler(), n_models
+        )
+
+    def predict(self, x, significance=None):
+        ncal_ngt_neq = np.stack(
+            [p._get_stats(x) for p in self.predictors], axis=3
+        )
+        ncal_ngt_neq = ncal_ngt_neq.sum(axis=3)
+
+        p = calc_p(
+            ncal_ngt_neq[:, :, 0] + ncal_ngt_neq[:, :, 0] / self.n_train,
+            ncal_ngt_neq[:, :, 1] + ncal_ngt_neq[:, :, 0] / self.n_train,
+            ncal_ngt_neq[:, :, 2],
+            smoothing=self.predictors[0].smoothing,
+        )
+
+        if significance:
+            return p > significance
+        else:
+            return p

unifiedbooster/nonconformist/base.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+
+"""
+docstring
+"""
+
+# Authors: Henrik Linusson
+
+import abc
+import numpy as np
+
+from sklearn.base import BaseEstimator, RegressorMixin, ClassifierMixin
+
+
+class RegressorMixin(object):
+    def __init__(self):
+        super(RegressorMixin, self).__init__()
+
+    @classmethod
+    def get_problem_type(cls):
+        return "regression"
+
+
+class ClassifierMixin(object):
+    def __init__(self):
+        super(ClassifierMixin, self).__init__()
+
+    @classmethod
+    def get_problem_type(cls):
+        return "classification"
+
+
+class BaseModelAdapter(BaseEstimator):
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, model, fit_params=None):
+        super(BaseModelAdapter, self).__init__()
+
+        self.model = model
+        self.last_x, self.last_y = None, None
+        self.clean = False
+        self.fit_params = {} if fit_params is None else fit_params
+
+    def fit(self, x, y):
+        """Fits the model.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of examples for fitting the model.
+
+        y : numpy array of shape [n_samples]
+                Outputs of examples for fitting the model.
+
+        Returns
+        -------
+        None
+        """
+
+        self.model.fit(x, y, **self.fit_params)
+        self.clean = False
+
+    def predict(self, x):
+        """Returns the prediction made by the underlying model.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of test examples.
+
+        Returns
+        -------
+        y : numpy array of shape [n_samples]
+                Predicted outputs of test examples.
+        """
+        if (
+            not self.clean
+            or self.last_x is None
+            or self.last_y is None
+            or not np.array_equal(self.last_x, x)
+        ):
+            self.last_x = x
+            self.last_y = self._underlying_predict(x)
+            self.clean = True
+
+        return self.last_y.copy()
+
+    @abc.abstractmethod
+    def _underlying_predict(self, x):
+        """Produces a prediction using the encapsulated model.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of test examples.
+
+        Returns
+        -------
+        y : numpy array of shape [n_samples]
+                Predicted outputs of test examples.
+        """
+        pass
+
+
+class ClassifierAdapter(BaseModelAdapter, ClassifierMixin):
+    def __init__(self, model, fit_params=None):
+        super(ClassifierAdapter, self).__init__(model, fit_params)
+
+    def _underlying_predict(self, x):
+        return self.model.predict_proba(x)
+
+
+class RegressorAdapter(BaseModelAdapter, RegressorMixin):
+    def __init__(self, model, fit_params=None):
+        super(RegressorAdapter, self).__init__(model, fit_params)
+
+    def _underlying_predict(self, x):
+        return self.model.predict(x)
+
+
+class OobMixin(object):
+    def __init__(self, model, fit_params=None):
+        super(OobMixin, self).__init__(model, fit_params)
+        self.train_x = None
+
+    def fit(self, x, y):
+        super(OobMixin, self).fit(x, y)
+        self.train_x = x
+
+    def _underlying_predict(self, x):
+        # TODO: sub-sampling of ensemble for test patterns
+        oob = x == self.train_x
+
+        if hasattr(oob, "all"):
+            oob = oob.all()
+
+        if oob:
+            return self._oob_prediction()
+        else:
+            return super(OobMixin, self)._underlying_predict(x)
+
+
+class OobClassifierAdapter(OobMixin, ClassifierAdapter):
+    def __init__(self, model, fit_params=None):
+        super(OobClassifierAdapter, self).__init__(model, fit_params)
+
+    def _oob_prediction(self):
+        return self.model.oob_decision_function_
+
+
+class OobRegressorAdapter(OobMixin, RegressorAdapter):
+    def __init__(self, model, fit_params=None):
+        super(OobRegressorAdapter, self).__init__(model, fit_params)
+
+    def _oob_prediction(self):
+        return self.model.oob_prediction_

unifiedbooster/nonconformist/cp.py

@@ -0,0 +1,172 @@
+from .icp import *
+
+# TODO: move contents from nonconformist.icp here
+
+
+# -----------------------------------------------------------------------------
+# TcpClassifier
+# -----------------------------------------------------------------------------
+class TcpClassifier(BaseEstimator, ClassifierMixin):
+    """Transductive conformal classifier.
+
+    Parameters
+    ----------
+    nc_function : BaseScorer
+            Nonconformity scorer object used to calculate nonconformity of
+            calibration examples and test patterns. Should implement ``fit(x, y)``
+            and ``calc_nc(x, y)``.
+
+    smoothing : boolean
+            Decides whether to use stochastic smoothing of p-values.
+
+    Attributes
+    ----------
+    train_x : numpy array of shape [n_cal_examples, n_features]
+            Inputs of training set.
+
+    train_y : numpy array of shape [n_cal_examples]
+            Outputs of calibration set.
+
+    nc_function : BaseScorer
+            Nonconformity scorer object used to calculate nonconformity scores.
+
+    classes : numpy array of shape [n_classes]
+            List of class labels, with indices corresponding to output columns
+             of TcpClassifier.predict()
+
+    See also
+    --------
+    IcpClassifier
+
+    References
+    ----------
+    .. [1] Vovk, V., Gammerman, A., & Shafer, G. (2005). Algorithmic learning
+    in a random world. Springer Science & Business Media.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import load_iris
+    >>> from sklearn.svm import SVC
+    >>> from nonconformist.base import ClassifierAdapter
+    >>> from nonconformist.cp import TcpClassifier
+    >>> from nonconformist.nc import ClassifierNc, MarginErrFunc
+    >>> iris = load_iris()
+    >>> idx = np.random.permutation(iris.target.size)
+    >>> train = idx[:int(idx.size / 2)]
+    >>> test = idx[int(idx.size / 2):]
+    >>> model = ClassifierAdapter(SVC(probability=True))
+    >>> nc = ClassifierNc(model, MarginErrFunc())
+    >>> tcp = TcpClassifier(nc)
+    >>> tcp.fit(iris.data[train, :], iris.target[train])
+    >>> tcp.predict(iris.data[test, :], significance=0.10)
+    ...             # doctest: +SKIP
+    array([[ True, False, False],
+            [False,  True, False],
+            ...,
+            [False,  True, False],
+            [False,  True, False]], dtype=bool)
+    """
+
+    def __init__(self, nc_function, condition=None, smoothing=True):
+        self.train_x, self.train_y = None, None
+        self.nc_function = nc_function
+        super(TcpClassifier, self).__init__()
+
+        # Check if condition-parameter is the default function (i.e.,
+        # lambda x: 0). This is so we can safely clone the object without
+        # the clone accidentally having self.conditional = True.
+        def default_condition(x):
+            return 0
+
+        is_default = callable(condition) and (
+            condition.__code__.co_code == default_condition.__code__.co_code
+        )
+
+        if is_default:
+            self.condition = condition
+            self.conditional = False
+        elif callable(condition):
+            self.condition = condition
+            self.conditional = True
+        else:
+            self.condition = lambda x: 0
+            self.conditional = False
+
+        self.smoothing = smoothing
+
+        self.base_icp = IcpClassifier(
+            self.nc_function, self.condition, self.smoothing
+        )
+
+        self.classes = None
+
+    def fit(self, x, y):
+        self.train_x, self.train_y = x, y
+        self.classes = np.unique(y)
+
+    def predict(self, x, significance=None):
+        """Predict the output values for a set of input patterns.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of patters for which to predict output values.
+
+        significance : float or None
+                Significance level (maximum allowed error rate) of predictions.
+                Should be a float between 0 and 1. If ``None``, then the p-values
+                are output rather than the predictions.
+
+        Returns
+        -------
+        p : numpy array of shape [n_samples, n_classes]
+                If significance is ``None``, then p contains the p-values for each
+                sample-class pair; if significance is a float between 0 and 1, then
+                p is a boolean array denoting which labels are included in the
+                prediction sets.
+        """
+        n_test = x.shape[0]
+        n_train = self.train_x.shape[0]
+        p = np.zeros((n_test, self.classes.size))
+        for i in range(n_test):
+            for j, y in enumerate(self.classes):
+                train_x = np.vstack([self.train_x, x[i, :]])
+                train_y = np.hstack([self.train_y, y])
+                self.base_icp.fit(train_x, train_y)
+                scores = self.base_icp.nc_function.score(train_x, train_y)
+                ngt = (scores[:-1] > scores[-1]).sum()
+                neq = (scores[:-1] == scores[-1]).sum()
+
+                p[i, j] = calc_p(n_train, ngt, neq, self.smoothing)
+
+        if significance is not None:
+            return p > significance
+        else:
+            return p
+
+    def predict_conf(self, x):
+        """Predict the output values for a set of input patterns, using
+        the confidence-and-credibility output scheme.
+
+        Parameters
+        ----------
+        x : numpy array of shape [n_samples, n_features]
+                Inputs of patters for which to predict output values.
+
+        Returns
+        -------
+        p : numpy array of shape [n_samples, 3]
+                p contains three columns: the first column contains the most
+                likely class for each test pattern; the second column contains
+                the confidence in the predicted class label, and the third column
+                contains the credibility of the prediction.
+        """
+        p = self.predict(x, significance=None)
+        label = p.argmax(axis=1)
+        credibility = p.max(axis=1)
+        for i, idx in enumerate(label):
+            p[i, idx] = -np.inf
+        confidence = 1 - p.max(axis=1)
+
+        return np.array([label, confidence, credibility]).T