unifiedbooster 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

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
+
+
+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):
+    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):
+    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