Merge pull request #1 from rth/fastfood

Add Fastfood algorithm

Author: rth

.circleci/config.yml

@@ -14,7 +14,7 @@ jobs:
             conda update --yes --quiet conda
             conda create -n testenv --yes --quiet python=3
             source activate testenv
-            conda install --yes pip numpy scipy scikit-learn matplotlib sphinx sphinx_rtd_theme numpydoc pillow
+            conda install --yes pip numpy scipy scikit-learn matplotlib sphinx sphinx_rtd_theme numpydoc pillow cython nomkl
             pip install sphinx-gallery
             pip install .
             cd doc

.gitignore

@@ -3,6 +3,8 @@ __pycache__/
 *.py[cod]
 *$py.class
 
+*.c
+
 # C extensions
 *.so
 

.travis.yml

@@ -15,6 +15,8 @@ matrix:
            SKLEARN_VERSION="0.20.2"
     - env: PYTHON_VERSION="3.7" NUMPY_VERSION="*" SCIPY_VERSION="*"
            SKLEARN_VERSION="*"
+    - env: PYTHON_VERSION="3.7" NUMPY_VERSION="*" SCIPY_VERSION="*"
+           SKLEARN_VERSION="nightly"
 
 install:
   # install miniconda
@@ -27,7 +29,14 @@ install:
   # create the testing environment
   - conda create -n testenv --yes python=$PYTHON_VERSION pip
   - source activate testenv
-  - conda install --yes numpy==$NUMPY_VERSION scipy==$SCIPY_VERSION scikit-learn==$SKLEARN_VERSION nose pytest pytest-cov
+  - |
+      if [ $SKLEARN_VERSION = "nightly" ]; then
+          conda install --yes numpy==$NUMPY_VERSION scipy==$SCIPY_VERSION cython nose pytest pytest-cov
+          # install nightly wheels
+          pip install --pre -f https://sklearn-nightly.scdn8.secure.raxcdn.com scikit-learn
+      else
+          conda install --yes numpy==$NUMPY_VERSION scipy==$SCIPY_VERSION scikit-learn==$SKLEARN_VERSION cython nose pytest pytest-cov
+      fi
   - pip install codecov
   - pip install .
 

benchmarks/bench_rbfsampler_fastfood.py

@@ -0,0 +1,56 @@
+import datetime
+
+import numpy as np
+
+from sklearn.kernel_approximation import Fastfood
+from sklearn.kernel_approximation import RBFSampler
+from sklearn.utils.testing import assert_greater
+
+"""compares the performance of Fastfood and RKS"""
+# generate data
+rng = np.random.RandomState(0)
+X = rng.random_sample(size=(1000, 4096))
+Y = rng.random_sample(size=(10000, 4096))
+X /= X.sum(axis=1)[:, np.newaxis]
+Y /= Y.sum(axis=1)[:, np.newaxis]
+
+# calculate feature maps
+gamma = 10.
+sigma = np.sqrt(1 / (2 * gamma))
+number_of_features_to_generate = 4096*4
+
+exact_start = datetime.datetime.utcnow()
+# original rbf kernel method:
+# rbf_kernel(X, X, gamma=gamma)
+# rbf_kernel(X, Y, gamma=gamma)
+exact_end = datetime.datetime.utcnow()
+exact_spent_time = exact_end - exact_start
+print("Timimg exact rbf: \t\t", exact_spent_time)
+
+rbf_transform = Fastfood(sigma=sigma,
+                         n_components=number_of_features_to_generate,
+                         tradeoff_mem_accuracy='mem',
+                         random_state=42)
+_ = rbf_transform.fit(X)
+fastfood_fast_vec_start = datetime.datetime.utcnow()
+# Fastfood: approximate kernel mapping
+_ = rbf_transform.transform(X)
+_ = rbf_transform.transform(Y)
+fastfood_fast_vec_end = datetime.datetime.utcnow()
+fastfood_fast_vec_spent_time = fastfood_fast_vec_end - \
+    fastfood_fast_vec_start
+print("Timimg fastfood fast vectorized: \t\t", fastfood_fast_vec_spent_time)
+
+rks_rbf_transform = RBFSampler(gamma=gamma,
+                               n_components=number_of_features_to_generate,
+                               random_state=42)
+_ = rks_rbf_transform.fit(X)
+rks_start = datetime.datetime.utcnow()
+# Random Kitchens Sinks: approximate kernel mapping
+_ = rks_rbf_transform.transform(X)
+_ = rks_rbf_transform.transform(Y)
+rks_end = datetime.datetime.utcnow()
+rks_spent_time = rks_end - rks_start
+print("Timimg rks: \t\t\t", rks_spent_time)
+
+assert_greater(rks_spent_time, fastfood_fast_vec_spent_time)

examples/plot_digits_classification_fastfood.py

@@ -0,0 +1,108 @@
+"""
+===================================================================
+Recognizing hand-written digits using Fastfood kernel approximation
+===================================================================
+
+This shows how the Fastfood kernel approximation compares to a dual and primal
+support vector classifier. It is based on the plot_digits_classification
+example of scikit-learn. The idea behind Fastfood is to map the data into a
+feature space (approximation) and then run a linear classifier on the mapped
+data.
+
+
+"""
+
+print(__doc__)
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Modified By: Felix Maximilian Möller
+# License: Simplified BSD
+
+# Standard scientific Python imports
+import numpy as np
+import pylab as pl
+
+# Import datasets, classifiers and performance metrics
+from sklearn import datasets, svm, metrics
+
+from sklearn_extra.kernel_approximation import Fastfood
+
+# The digits dataset
+digits = datasets.load_digits()
+
+# The data that we are interested in is made of 8x8 images of digits,
+# let's have a look at the first 3 images, stored in the `images`
+# attribute of the dataset. If we were working from image files, we
+# could load them using pylab.imread. For these images know which
+# digit they represent: it is given in the 'target' of the dataset.
+for index, (image, label) in enumerate(zip(digits.images, digits.target)):
+    pl.subplot(2, 4, index + 1)
+    pl.axis('off')
+    pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest')
+    pl.title('Training: %i' % label)
+    if index > 3:
+        break
+
+# To apply an classifier on this data, we need to flatten the image, to
+# turn the data in a (samples, feature) matrix:
+n_samples = len(digits.images)
+data = digits.images.reshape((n_samples, -1))
+gamma = .001
+sigma = np.sqrt(1 / (2 * gamma))
+number_of_features_to_generate = 1000
+train__idx = range(n_samples // 2)
+test__idx = range(n_samples // 2, n_samples)
+
+# map data into featurespace
+rbf_transform = Fastfood(
+    sigma=sigma, n_components=number_of_features_to_generate)
+data_transformed_train = rbf_transform.fit_transform(data[train__idx])
+data_transformed_test = rbf_transform.transform(data[test__idx])
+
+# Create a classifier: a support vector classifier
+classifier = svm.SVC(gamma=gamma)
+linear_classifier = svm.LinearSVC()
+linear_classifier_transformation = svm.LinearSVC()
+
+# We learn the digits on the first half of the digits
+classifier.fit(data[train__idx], digits.target[train__idx])
+linear_classifier.fit(data[train__idx], digits.target[train__idx])
+
+# Run the linear classifier on the mapped data.
+linear_classifier_transformation.fit(
+    data_transformed_train, digits.target[train__idx])
+
+# Now predict the value of the digit on the second half:
+expected = digits.target[test__idx]
+predicted = classifier.predict(data[test__idx])
+predicted_linear = linear_classifier.predict(data[test__idx])
+predicted_linear_transformed = linear_classifier_transformation.predict(
+    data_transformed_test)
+
+print("Classification report for dual classifier %s:\n%s\n"
+      % (classifier, metrics.classification_report(expected, predicted)))
+print("Classification report for primal linear classifier %s:\n%s\n"
+      % (linear_classifier,
+         metrics.classification_report(expected, predicted_linear)))
+print(
+    "Classification report for primal transformation classifier %s:\n%s\n"
+    % (linear_classifier_transformation,
+       metrics.classification_report(expected, predicted_linear_transformed)))
+
+print("Confusion matrix for dual classifier:\n%s"
+      % metrics.confusion_matrix(expected, predicted))
+print("Confusion matrix for primal linear classifier:\n%s"
+      % metrics.confusion_matrix(expected, predicted_linear))
+print("Confusion matrix for for primal transformation classifier:\n%s"
+      % metrics.confusion_matrix(expected, predicted_linear_transformed))
+
+for index, (image, prediction) in enumerate(
+        zip(digits.images[test__idx], predicted)):
+    pl.subplot(2, 4, index + 4)
+    pl.axis('off')
+    pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest')
+    pl.title('Prediction: %i' % prediction)
+    if index > 3:
+        break
+
+pl.show()