renamed module

Author: mrahim

examples/fmri_stacking.py

@@ -0,0 +1,18 @@
+from sklearn.datasets import make_classification
+from sklearn.linear_model import LogisticRegression, RidgeClassifier
+from sklearn.svm import LinearSVC
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import ShuffleSplit
+from stlearn import StackingClassifier
+
+n = 20
+X, y = make_classification(n_samples=200, random_state=42)
+ss = ShuffleSplit(n_splits=10, test_size=0.2, random_state=42)
+
+stacking = StackingClassifier(estimators=n*[LogisticRegression()],
+                              stacking_estimator=LogisticRegression())
+
+for train, test in ss.split(X):
+    stacking.fit(n*[X[train]], y[train])
+    print(stacking.score(n*[X[test]], y[test]))
+    print(stacking.score_estimators(n*[X[test]], y[test]))

setup.py

@@ -5,7 +5,7 @@
 
 
 descr = """A scikit-learn based library for prediction stacking."""
-DISTNAME = 'stacked-learn'
+DISTNAME = 'stlearn'
 DESCRIPTION = 'A scikit-learn based library for prediction stacking.'
 LONG_DESCRIPTION = descr
 MAINTAINER = 'Mehdi Rahim'
@@ -30,7 +30,7 @@ def configuration(parent_package='', top_path=None):
     from numpy.distutils.misc_util import Configuration
     config = Configuration(None, parent_package, top_path)
 
-    config.add_subpackage('cobre_analysis')
+    config.add_subpackage('stlearn')
 
     return config
 

stacked-learn/__init__.py

@@ -0,0 +1 @@
+from .stacking import StackingClassifier

stacked-learn/stacking.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+"""
+Prediction stacking API
+"""
+# Author: Mehdi Rahim <rahim.mehdi@gmail.com>
+#
+# License: BSD 3 clause
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin, ClassifierMixin
+from sklearn.metrics import accuracy_score
+from sklearn.externals.joblib import Memory, Parallel, delayed
+
+
+def fit_estimator(clf, X, y):
+    return clf.fit(X, y)
+
+
+def predict_estimator(clf, X):
+    return clf.predict(X)
+
+
+def predict_proba_estimator(clf, X):
+    # try predict_proba
+    predict_proba = getattr(clf, "predict_proba", None)
+    if callable(predict_proba):
+        return clf.predict_proba(X)[:, 0]
+
+    # or decision_function
+    decision_function = getattr(clf, "decision_function", None)
+    if callable(decision_function):
+        return clf.decision_function(X)
+
+    raise NotImplementedError("predict_proba not supported")
+
+
+class StackingClassifier(BaseEstimator, ClassifierMixin, TransformerMixin):
+    """Meta-classifier of 3D X matrix with labels
+    """
+
+    def __init__(self, estimators=None,
+                 stacking_estimator=None,
+                 memory=Memory(cachedir=None), memory_level=0,
+                 n_jobs=1):
+        """ initialization
+        """
+        self.estimators = estimators
+        self.stacking_estimator = stacking_estimator
+        self.memory = memory
+        self.memory_level = memory_level
+        self.n_jobs = n_jobs
+
+    def fit(self, X, y):
+        """ stacking model fitting
+        X is 3D matrix
+        """
+
+        self.estimators = Parallel(n_jobs=self.n_jobs)(
+            delayed(fit_estimator)(clf, x, y)
+            for x, clf in zip(X, self.estimators))
+
+        predictions_ = Parallel(n_jobs=self.n_jobs)(
+            delayed(predict_proba_estimator)(clf, x)
+            for x, clf in zip(X, self.estimators))
+        predictions_ = np.array(predictions_).T
+
+        self.stacking_estimator.fit(predictions_, y)
+        return self
+
+    def predict(self, X):
+        """ stacking model prediction
+        X is 3D matrix
+        """
+
+        predictions_ = Parallel(n_jobs=self.n_jobs)(
+            delayed(predict_proba_estimator)(clf, x)
+            for x, clf in zip(X, self.estimators))
+        predictions_ = np.array(predictions_).T
+
+        return self.stacking_estimator.predict(predictions_)
+
+    def score(self, X, y):
+        """ stacking model accuracy
+        """
+        return accuracy_score(y, self.predict(X))
+
+    def predict_estimators(self, X):
+        """ prediction from separate estimators
+        """
+        predictions_ = Parallel(n_jobs=self.n_jobs)(
+            delayed(predict_estimator)(clf, x)
+            for x, clf in zip(X, self.estimators))
+        return np.array(predictions_).T
+
+    def score_estimators(self, X, y):
+        """ accuracy from separate estimators
+        """
+        predictions_ = self.predict_estimators(X)
+        return np.array([accuracy_score(y, p) for p in predictions_.T])