scikit-learn · viclafargue · Feb 21, 2020 · Feb 21, 2020 · Feb 21, 2020 · Feb 21, 2020
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
@@ -67,23 +67,23 @@ jobs:
         SKLEARN_SKIP_NETWORK_TESTS: '0'
 
 # Will run all the time regardless of linting outcome.
-- template: build_tools/azure/posix.yml
-  parameters:
-    name: Linux_Runs
-    vmImage: ubuntu-18.04
-    matrix:
-      pylatest_conda_mkl:
-        DISTRIB: 'conda'
-        PYTHON_VERSION: '*'
-        BLAS: 'mkl'
-        NUMPY_VERSION: '*'
-        SCIPY_VERSION: '*'
-        CYTHON_VERSION: '*'
-        PILLOW_VERSION: '*'
-        PYTEST_VERSION: '*'
-        JOBLIB_VERSION: '*'
-        THREADPOOLCTL_VERSION: '2.0.0'
-        COVERAGE: 'true'
+# - template: build_tools/azure/posix.yml
+#   parameters:
+#     name: Linux_Runs
+#     vmImage: ubuntu-18.04
+#     matrix:
+#       pylatest_conda_mkl:
+#         DISTRIB: 'conda'
+#         PYTHON_VERSION: '*'
+#         BLAS: 'mkl'
+#         NUMPY_VERSION: '*'
+#         SCIPY_VERSION: '*'
+#         CYTHON_VERSION: '*'
+#         PILLOW_VERSION: '*'
+#         PYTEST_VERSION: '*'
+#         JOBLIB_VERSION: '*'
+#         THREADPOOLCTL_VERSION: '2.0.0'
+#         COVERAGE: 'true'
 
 - template: build_tools/azure/posix.yml
   parameters:
@@ -95,31 +95,31 @@ jobs:
       # Linux environment to test that scikit-learn can be built against
       # versions of numpy, scipy with ATLAS that comes with Ubuntu Bionic 18.04
       # i.e. numpy 1.13.3 and scipy 0.19
-      py36_ubuntu_atlas:
-        DISTRIB: 'ubuntu'
-        PYTHON_VERSION: '3.6'
-        JOBLIB_VERSION: '0.11'
-        PYTEST_XDIST: 'false'
-        THREADPOOLCTL_VERSION: '2.0.0'
-      # Linux + Python 3.6 build with OpenBLAS and without SITE_JOBLIB
-      py36_conda_openblas:
-        DISTRIB: 'conda'
-        PYTHON_VERSION: '3.6'
-        BLAS: 'openblas'
-        NUMPY_VERSION: '1.13.3'
-        SCIPY_VERSION: '0.19.1'
-        PANDAS_VERSION: '*'
-        CYTHON_VERSION: '*'
-        # temporary pin pytest due to unknown failure with pytest 5.3
-        PYTEST_VERSION: '5.2'
-        PILLOW_VERSION: '4.2.1'
-        MATPLOTLIB_VERSION: '2.1.1'
-        SCIKIT_IMAGE_VERSION: '*'
-        # latest version of joblib available in conda for Python 3.6
-        JOBLIB_VERSION: '0.13.2'
-        THREADPOOLCTL_VERSION: '2.0.0'
-        PYTEST_XDIST: 'false'
-        COVERAGE: 'true'
+      # py36_ubuntu_atlas:
+      #   DISTRIB: 'ubuntu'
+      #   PYTHON_VERSION: '3.6'
+      #   JOBLIB_VERSION: '0.11'
+      #   PYTEST_XDIST: 'false'
+      #   THREADPOOLCTL_VERSION: '2.0.0'
+      # # Linux + Python 3.6 build with OpenBLAS and without SITE_JOBLIB
+      # py36_conda_openblas:
+      #   DISTRIB: 'conda'
+      #   PYTHON_VERSION: '3.6'
+      #   BLAS: 'openblas'
+      #   NUMPY_VERSION: '1.13.3'
+      #   SCIPY_VERSION: '0.19.1'
+      #   PANDAS_VERSION: '*'
+      #   CYTHON_VERSION: '*'
+      #   # temporary pin pytest due to unknown failure with pytest 5.3
+      #   PYTEST_VERSION: '5.2'
+      #   PILLOW_VERSION: '4.2.1'
+      #   MATPLOTLIB_VERSION: '2.1.1'
+      #   SCIKIT_IMAGE_VERSION: '*'
+      #   # latest version of joblib available in conda for Python 3.6
+      #   JOBLIB_VERSION: '0.13.2'
+      #   THREADPOOLCTL_VERSION: '2.0.0'
+      #   PYTEST_XDIST: 'false'
+      #   COVERAGE: 'true'
       # Linux environment to test the latest available dependencies and MKL.
       # It runs tests requiring lightgbm, pandas and PyAMG.
       pylatest_pip_openblas_pandas:
@@ -131,66 +131,66 @@ jobs:
         TEST_DOCSTRINGS: 'true'
         CHECK_WARNINGS: 'true'
 
-- template: build_tools/azure/posix-32.yml
-  parameters:
-    name: Linux32
-    vmImage: ubuntu-18.04
-    dependsOn: [linting]
-    condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
-    matrix:
-      py36_ubuntu_atlas_32bit:
-        DISTRIB: 'ubuntu-32'
-        PYTHON_VERSION: '3.6'
-        JOBLIB_VERSION: '0.13'
-        THREADPOOLCTL_VERSION: '2.0.0'
+# - template: build_tools/azure/posix-32.yml
+#   parameters:
+#     name: Linux32
+#     vmImage: ubuntu-18.04
+#     dependsOn: [linting]
+#     condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
+#     matrix:
+#       py36_ubuntu_atlas_32bit:
+#         DISTRIB: 'ubuntu-32'
+#         PYTHON_VERSION: '3.6'
+#         JOBLIB_VERSION: '0.13'
+#         THREADPOOLCTL_VERSION: '2.0.0'
 
-- template: build_tools/azure/posix.yml
-  parameters:
-    name: macOS
-    vmImage: macOS-10.14
-    dependsOn: [linting]
-    condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
-    matrix:
-      pylatest_conda_mkl:
-        DISTRIB: 'conda'
-        PYTHON_VERSION: '*'
-        BLAS: 'mkl'
-        NUMPY_VERSION: '*'
-        SCIPY_VERSION: '*'
-        CYTHON_VERSION: '*'
-        PILLOW_VERSION: '*'
-        PYTEST_VERSION: '*'
-        JOBLIB_VERSION: '*'
-        THREADPOOLCTL_VERSION: '2.0.0'
-        COVERAGE: 'true'
-      pylatest_conda_mkl_no_openmp:
-        DISTRIB: 'conda'
-        PYTHON_VERSION: '*'
-        BLAS: 'mkl'
-        NUMPY_VERSION: '*'
-        SCIPY_VERSION: '*'
-        CYTHON_VERSION: '*'
-        PILLOW_VERSION: '*'
-        PYTEST_VERSION: '*'
-        JOBLIB_VERSION: '*'
-        THREADPOOLCTL_VERSION: '2.0.0'
-        COVERAGE: 'true'
-        SKLEARN_TEST_NO_OPENMP: 'true'
-        SKLEARN_SKIP_OPENMP_TEST: 'true'
+# - template: build_tools/azure/posix.yml
+#   parameters:
+#     name: macOS
+#     vmImage: macOS-10.14
+#     dependsOn: [linting]
+#     condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
+#     matrix:
+#       pylatest_conda_mkl:
+#         DISTRIB: 'conda'
+#         PYTHON_VERSION: '*'
+#         BLAS: 'mkl'
+#         NUMPY_VERSION: '*'
+#         SCIPY_VERSION: '*'
+#         CYTHON_VERSION: '*'
+#         PILLOW_VERSION: '*'
+#         PYTEST_VERSION: '*'
+#         JOBLIB_VERSION: '*'
+#         THREADPOOLCTL_VERSION: '2.0.0'
+#         COVERAGE: 'true'
+#       pylatest_conda_mkl_no_openmp:
+#         DISTRIB: 'conda'
+#         PYTHON_VERSION: '*'
+#         BLAS: 'mkl'
+#         NUMPY_VERSION: '*'
+#         SCIPY_VERSION: '*'
+#         CYTHON_VERSION: '*'
+#         PILLOW_VERSION: '*'
+#         PYTEST_VERSION: '*'
+#         JOBLIB_VERSION: '*'
+#         THREADPOOLCTL_VERSION: '2.0.0'
+#         COVERAGE: 'true'
+#         SKLEARN_TEST_NO_OPENMP: 'true'
+#         SKLEARN_SKIP_OPENMP_TEST: 'true'
 
-- template: build_tools/azure/windows.yml
-  parameters:
-    name: Windows
-    vmImage: vs2017-win2016
-    dependsOn: [linting]
-    condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
-    matrix:
-      py37_conda_mkl:
-        PYTHON_VERSION: '3.7'
-        CHECK_WARNINGS: 'true'
-        PYTHON_ARCH: '64'
-        PYTEST_VERSION: '*'
-        COVERAGE: 'true'
-      py36_pip_openblas_32bit:
-        PYTHON_VERSION: '3.6'
-        PYTHON_ARCH: '32'
+# - template: build_tools/azure/windows.yml
+#   parameters:
+#     name: Windows
+#     vmImage: vs2017-win2016
+#     dependsOn: [linting]
+#     condition: and(ne(variables['Build.Reason'], 'Schedule'), succeeded('linting'))
+#     matrix:
+#       py37_conda_mkl:
+#         PYTHON_VERSION: '3.7'
+#         CHECK_WARNINGS: 'true'
+#         PYTHON_ARCH: '64'
+#         PYTEST_VERSION: '*'
+#         COVERAGE: 'true'
+#       py36_pip_openblas_32bit:
+#         PYTHON_VERSION: '3.6'
+#         PYTHON_ARCH: '32'
diff --git a/benchmarks/bench_pca_gpu.py b/benchmarks/bench_pca_gpu.py
@@ -0,0 +1,82 @@
+"""
+A comparison of PCA with/wthout GPU
+
+Obtained with NVIDIA Tesla V100
+
+With svd_solver='full' and iterated_power=2:
+        Without GPU : runtime: 1.197s, explained variance: 6.967
+        With CuPy : runtime: 0.016s, explained variance: 6.967
+        With cuML : runtime: 0.007s, explained variance: 6.967
+
+With svd_solver='full' and iterated_power=10:
+        Without GPU : runtime: 1.210s, explained variance: 6.967
+        With CuPy : runtime: 0.016s, explained variance: 6.967
+        With cuML : runtime: 0.007s, explained variance: 6.967
+
+With svd_solver='randomized' and iterated_power=2:
+        Without GPU : runtime: 0.032s, explained variance: 6.745
+        With CuPy : runtime: 0.012s, explained variance: 6.693
+
+With svd_solver='randomized' and iterated_power=10:
+        Without GPU : runtime: 0.204s, explained variance: 6.945
+        With CuPy : runtime: 0.040s, explained variance: 6.949
+"""
+
+import sklearn
+from sklearn.datasets import make_classification
+from sklearn.decomposition import PCA
+from cuml.decomposition import PCA as cumlPCA
+import numpy as np
+import cupy as cp
+import time
+
+
+if __name__ == '__main__':
+    import cupy
+    X_np, y_np = make_classification(n_samples=10000, n_features=100)
+    X_np = X_np.astype(np.float32)
+    X_cp = cp.asfortranarray(cp.asarray(X_np))
+
+    for svd_solver in ["full", "randomized"]:
+        for iterated_power in [2, 10]:
+            pca_np = PCA(n_components=3, svd_solver=svd_solver, copy=True,
+                         random_state=0, iterated_power=iterated_power)
+            pca_np.fit_transform(X_np)  # Warm-up
+            pca_np = PCA(**pca_np.get_params())  # Overwrite to clean model
+            t0 = time.time()
+            pca_np.fit_transform(X_np)
+            without_gpu_time = time.time() - t0
+            exp_var_np = pca_np.explained_variance_.sum()
+
+            cupy_time = 0
+            exp_var_cp = 0
+            with sklearn.config_context(enable_duck_array=True):
+                pca_cp = PCA(**pca_np.get_params())
+                pca_cp.fit_transform(X_cp)  # Warm-up
+                pca_cp = PCA(**pca_np.get_params())  # Overwrite to clean model
+                t0 = time.time()
+                pca_cp.fit_transform(X_cp)
+                cupy_time = time.time() - t0
+                exp_var_cp = cp.asnumpy(pca_cp.explained_variance_.sum())
+
+            if svd_solver == 'full':
+                pca_cuml = cumlPCA(**pca_np.get_params())
+                pca_cuml.fit_transform(X_cp)  # Warm-up
+                pca_cuml = cumlPCA(**pca_np.get_params())  # Overwrite to clean model
+                t0 = time.time()
+                pca_cuml.fit_transform(X_cp)
+                cuml_time = time.time() - t0
+                exp_var_cuml = pca_np.explained_variance_.sum()
+
+            msg = 'With svd_solver=\'{}\' and iterated_power={}:'
+            print(msg.format(svd_solver, iterated_power))
+            m1 = '\tWithout GPU : runtime: {:.3f}s, explained variance: {:.3f}'
+            print(m1.format(without_gpu_time, exp_var_np))
+            m2 = '\tWith CuPy : runtime: {:.3f}s, explained variance: {:.3f}'
+            print(m2.format(cupy_time, exp_var_cp))
+
+            m3 = '\tWith cuML : runtime: {:.3f}s, explained variance: {:.3f}\n'
+            if svd_solver == 'full':
+                print(m3.format(cuml_time, exp_var_cuml))
+            else:
+                print()
diff --git a/build_tools/azure/install.sh b/build_tools/azure/install.sh
@@ -94,7 +94,7 @@ elif [[ "$DISTRIB" == "conda-pip-latest" ]]; then
     python -m pip install -U pip
     python -m pip install pytest==$PYTEST_VERSION pytest-cov
 
-    python -m pip install pandas matplotlib pyamg scikit-image
+    python -m pip install pandas matplotlib pyamg scikit-image jax jaxlib
     # do not install dependencies for lightgbm since it requires scikit-learn
     python -m pip install lightgbm --no-deps
 elif [[ "$DISTRIB" == "conda-pip-scipy-dev" ]]; then

diff --git a/build_tools/azure/test_script.sh b/build_tools/azure/test_script.sh
@@ -42,5 +42,5 @@ cp setup.cfg $TEST_DIR
 cd $TEST_DIR
 
 set -x
-$TEST_CMD --pyargs sklearn
+$TEST_CMD --pyargs sklearn.decomposition
 set +x
diff --git a/sklearn/_config.py b/sklearn/_config.py
@@ -8,6 +8,7 @@
     'working_memory': int(os.environ.get('SKLEARN_WORKING_MEMORY', 1024)),
     'print_changed_only': True,
     'display': 'text',
+    'enable_duck_array': False,
 }
 
 
@@ -28,7 +29,8 @@ def get_config():
 
 
 def set_config(assume_finite=None, working_memory=None,
-               print_changed_only=None, display=None):
+               print_changed_only=None, display=None,
+               enable_duck_array=None):
     """Set global scikit-learn configuration
 
     .. versionadded:: 0.19
@@ -80,6 +82,8 @@ def set_config(assume_finite=None, working_memory=None,
         _global_config['print_changed_only'] = print_changed_only
     if display is not None:
         _global_config['display'] = display
+    if enable_duck_array is not None:
+        _global_config['enable_duck_array'] = enable_duck_array
 
 
 @contextmanager

diff --git a/sklearn/decomposition/_base.py b/sklearn/decomposition/_base.py
@@ -9,7 +9,6 @@
 # License: BSD 3 clause
 
 import numpy as np
-from scipy import linalg
 
 from ..base import BaseEstimator, TransformerMixin
 from ..utils import check_array
@@ -44,7 +43,7 @@ def get_covariance(self):
         cov.flat[::len(cov) + 1] += self.noise_variance_  # modify diag inplace
         return cov
 
-    def get_precision(self):
+    def get_precision(self, npx=np):
         """Compute data precision matrix with the generative model.
 
         Equals the inverse of the covariance but computed with
@@ -61,7 +60,7 @@ def get_precision(self):
         if self.n_components_ == 0:
             return np.eye(n_features) / self.noise_variance_
         if self.n_components_ == n_features:
-            return linalg.inv(self.get_covariance())
+            return npx.linalg.inv(self.get_covariance())
 
         # Get precision using matrix inversion lemma
         components_ = self.components_
@@ -70,11 +69,11 @@ def get_precision(self):
             components_ = components_ * np.sqrt(exp_var[:, np.newaxis])
         exp_var_diff = np.maximum(exp_var - self.noise_variance_, 0.)
         precision = np.dot(components_, components_.T) / self.noise_variance_
-        precision.flat[::len(precision) + 1] += 1. / exp_var_diff
-        precision = np.dot(components_.T,
-                           np.dot(linalg.inv(precision), components_))
+        precision.ravel()[::len(precision) + 1] += 1. / exp_var_diff
+        precision = npx.dot(components_.T,
+                            npx.dot(npx.linalg.inv(precision), components_))
         precision /= -(self.noise_variance_ ** 2)
-        precision.flat[::len(precision) + 1] += 1. / self.noise_variance_
+        precision.ravel()[::len(precision) + 1] += 1. / self.noise_variance_
         return precision
 
     @abstractmethod