scikit-learn-intelex 2024.5.0__py39-none-manylinux1_x86_64.whl → 2024.7.0__py39-none-manylinux1_x86_64.whl

sklearnex/svm/svc.py

@@ -85,6 +85,17 @@ class SVC(sklearn_SVC, BaseSVC):
     def fit(self, X, y, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
+        elif self.C <= 0:
+            # else if added to correct issues with
+            # sklearn tests:
+            # svm/tests/test_sparse.py::test_error
+            # svm/tests/test_svm.py::test_bad_input
+            # for sklearn versions < 1.2 (i.e. without
+            # validate_params parameter checking)
+            # Without this, a segmentation fault with
+            # Windows fatal exception: access violation
+            # occurs
+            raise ValueError("C <= 0")
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
         dispatch(
@@ -96,8 +107,9 @@ class SVC(sklearn_SVC, BaseSVC):
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
+
         return self
 
     @wrap_output_data
@@ -270,12 +282,30 @@ class SVC(sklearn_SVC, BaseSVC):
             return patching_status
         raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
+    def _get_sample_weight(self, X, y, sample_weight=None):
+        sample_weight = super()._get_sample_weight(X, y, sample_weight)
+        if sample_weight is None:
+            return sample_weight
+
+        if np.any(sample_weight <= 0) and len(np.unique(y[sample_weight > 0])) != len(
+            self.classes_
+        ):
+            raise ValueError(
+                "Invalid input - all samples with positive weights "
+                "belong to the same class"
+                if sklearn_check_version("1.2")
+                else "Invalid input - all samples with positive weights "
+                "have the same label."
+            )
+        return sample_weight
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        X, _, weights = self._onedal_fit_checks(X, y, sample_weight)
         onedal_params = {
             "C": self.C,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -287,10 +317,16 @@ class SVC(sklearn_SVC, BaseSVC):
         }
 
         self._onedal_estimator = onedal_SVC(**onedal_params)
-        self._onedal_estimator.fit(X, y, sample_weight, queue=queue)
+        self._onedal_estimator.fit(X, y, weights, queue=queue)
 
         if self.probability:
-            self._fit_proba(X, y, sample_weight, queue=queue)
+            self._fit_proba(
+                X,
+                y,
+                sample_weight=sample_weight,
+                queue=queue,
+            )
+
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):

sklearnex/svm/svr.py

@@ -65,6 +65,17 @@ class SVR(sklearn_SVR, BaseSVR):
     def fit(self, X, y, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
+        elif self.C <= 0:
+            # else if added to correct issues with
+            # sklearn tests:
+            # svm/tests/test_sparse.py::test_error
+            # svm/tests/test_svm.py::test_bad_input
+            # for sklearn versions < 1.2 (i.e. without
+            # validate_params parameter checking)
+            # Without this, a segmentation fault with
+            # Windows fatal exception: access violation
+            # occurs
+            raise ValueError("C <= 0")
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
         dispatch(
@@ -76,7 +87,7 @@ class SVR(sklearn_SVR, BaseSVR):
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
 
         return self
@@ -95,13 +106,30 @@ class SVR(sklearn_SVR, BaseSVR):
             X,
         )
 
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        if sklearn_check_version("1.0"):
+            self._check_feature_names(X, reset=False)
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": sklearn_SVR.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        X, _, sample_weight = self._onedal_fit_checks(X, y, sample_weight)
         onedal_params = {
             "C": self.C,
             "epsilon": self.epsilon,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -118,3 +146,4 @@ class SVR(sklearn_SVR, BaseSVR):
 
     fit.__doc__ = sklearn_SVR.fit.__doc__
     predict.__doc__ = sklearn_SVR.predict.__doc__
+    score.__doc__ = sklearn_SVR.score.__doc__

sklearnex/svm/tests/test_svm.py

@@ -25,12 +25,10 @@ from onedal.tests.utils._dataframes_support import (
 )
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_svc(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("SVC fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import SVC
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -43,12 +41,10 @@ def test_sklearnex_import_svc(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [1, 3])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_nusvc(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("NuSVC fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import NuSVC
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -63,12 +59,10 @@ def test_sklearnex_import_nusvc(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [0, 1, 3, 4])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_svr(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("SVR fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import SVR
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
@@ -81,12 +75,10 @@ def test_sklearnex_import_svr(dataframe, queue):
     assert_allclose(_as_numpy(svc.support_), [1, 3])
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_nusvr(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("NuSVR fit for the GPU sycl_queue is buggy.")
     from sklearnex.svm import NuSVR
 
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])

sklearnex/tests/_utils.py

@@ -14,9 +14,11 @@
 # limitations under the License.
 # ==============================================================================
 
-from inspect import isclass
+from functools import partial
+from inspect import getattr_static, isclass, signature
 
 import numpy as np
+from scipy import sparse as sp
 from sklearn import clone
 from sklearn.base import (
     BaseEstimator,
@@ -42,6 +44,22 @@ from sklearnex.svm import SVC, NuSVC
 
 
 def _load_all_models(with_sklearnex=True, estimator=True):
+    """Convert sklearnex patch_map into a dictionary of estimators or functions
+
+    Parameters
+    ----------
+    with_sklearnex: bool (default=True)
+        Discover estimators and methods with sklearnex patching enabled (True)
+        or disabled (False) from the sklearnex patch_map
+
+    estimator: bool (default=True)
+        yield estimators (True) or functions (False)
+
+    Returns
+    -------
+    dict: {name:estimator}
+        estimator is a class or function from sklearn or sklearnex
+    """
     # insure that patch state is correct as dictated by patch_sklearn boolean
     # and return it to the previous state no matter what occurs.
     already_patched_map = sklearn_is_patched(return_map=True)
@@ -89,11 +107,17 @@ mixin_map = [
 
 
 class _sklearn_clone_dict(dict):
+    """Special dict type for returning state-free sklearn/sklearnex estimators
+    with the same parameters"""
 
     def __getitem__(self, key):
         return clone(super().__getitem__(key))
 
 
+# Special dictionary of sklearnex estimators which must be specifically tested, this
+# could be because of supported non-default parameters, blocked support via sklearn's
+# 'available_if' decorator, or not being a native sklearn estimator (i.e. those not in
+# the default PATCHED_MODELS dictionary)
 SPECIAL_INSTANCES = _sklearn_clone_dict(
     {
         str(i): i
@@ -110,27 +134,58 @@ SPECIAL_INSTANCES = _sklearn_clone_dict(
 )
 
 
-def gen_models_info(algorithms):
+def gen_models_info(algorithms, required_inputs=["X", "y"]):
+    """Generate estimator-attribute pairs for pytest test collection.
+
+    Parameters
+    ----------
+    algorithms : iterable (list, tuple, 1D array-like object)
+        Iterable of valid sklearnex estimators or keys from PATCHED_MODELS
+
+    required_inputs : list, tuple of strings or None
+        list of required args/kwargs for callable attribute (only non-private,
+        non-BaseEstimator attributes).  Only one must be present, None
+        signifies taking all non-private attribues, callable or not.
+
+    Returns
+    -------
+    list of 2-element tuples: (estimator, string)
+        Returns a list of valid methods or attributes without "fit"
+    """
     output = []
-    for i in algorithms:
+    for estimator in algorithms:
 
-        if i in PATCHED_MODELS:
-            est = PATCHED_MODELS[i]
-        elif i in SPECIAL_INSTANCES:
-            est = SPECIAL_INSTANCES[i].__class__
+        if estimator in PATCHED_MODELS:
+            est = PATCHED_MODELS[estimator]
+        elif isinstance(algorithms[estimator], BaseEstimator):
+            est = algorithms[estimator].__class__
         else:
-            raise KeyError(f"Unrecognized sklearnex estimator: {i}")
+            raise KeyError(f"Unrecognized sklearnex estimator: {estimator}")
 
-        methods = set()
-        candidates = set(
-            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
-        )
+        # remove BaseEstimator methods (get_params, set_params)
+        candidates = set(dir(est)) - set(dir(BaseEstimator))
+        # remove private methods
+        candidates = set([attr for attr in candidates if not attr.startswith("_")])
+        # required to enable other methods
+        candidates = candidates - {"fit"}
 
-        for mixin, method, _ in mixin_map:
-            if issubclass(est, mixin):
-                methods |= candidates & set(method)
+        # allow only callable methods with any of the required inputs
+        if required_inputs:
+            methods = []
+            for attr in candidates:
+                attribute = getattr_static(est, attr)
+                if callable(attribute):
+                    params = signature(attribute).parameters
+                    if any([inp in params for inp in required_inputs]):
+                        methods += [attr]
+        else:
+            methods = candidates
 
-        output += [[i, j] for j in methods] if methods else [[i, None]]
+        output += (
+            [(estimator, method) for method in methods]
+            if methods
+            else [(estimator, None)]
+        )
 
     # In the case that no methods are available, set method to None.
     # This will allow estimators without mixins to still test the fit
@@ -138,24 +193,124 @@ def gen_models_info(algorithms):
     return output
 
 
-def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
-    dataset = None
-    name = estimator.__class__.__name__
-    est = PATCHED_MODELS[name]
+def call_method(estimator, method, X, y, **kwargs):
+    """Generalized interface to call most sklearn estimator methods
+
+    Parameters
+    ----------
+    estimator : sklearn or sklearnex estimator instance
+
+    method: string
+        Valid callable method to estimator
+
+    X: array-like
+        data
+
+    y: array-like (for 'score', 'partial-fit', and 'path')
+        X-dependent data
+
+    **kwargs: keyword dict
+        keyword arguments to estimator.method
+
+    Returns
+    -------
+    return value from estimator.method
+    """
+    # useful for repository wide testing
+    if method == "inverse_transform":
+        # PCA's inverse_transform takes (n_samples, n_components)
+        data = (
+            (X[:, : estimator.n_components_],)
+            if X.shape[1] != estimator.n_components_
+            else (X,)
+        )
+    elif method not in ["score", "partial_fit", "path"]:
+        data = (X,)
+    else:
+        data = (X, y)
+    return getattr(estimator, method)(*data, **kwargs)
+
+
+def _gen_dataset_type(est):
+    # est should be an estimator or estimator class
+    # dataset initialized to classification, but will be swapped
+    # for other types as necessary. Private method.
+    dataset = "classification"
+    estimator = est.__class__ if isinstance(est, BaseEstimator) else est
+
     for mixin, _, data in mixin_map:
-        if issubclass(est, mixin) and data is not None:
+        if issubclass(estimator, mixin) and data is not None:
             dataset = data
+    return dataset
+
+
+_dataset_dict = {
+    "classification": [partial(load_iris, return_X_y=True)],
+    "regression": [partial(load_diabetes, return_X_y=True)],
+}
+
+
+def gen_dataset(
+    est,
+    datasets=_dataset_dict,
+    sparse=False,
+    queue=None,
+    target_df=None,
+    dtype=None,
+):
+    """Generate dataset for pytest testing.
+
+    Parameters
+    ----------
+    est : sklearn or sklearnex estimator class
+        Must inherit an sklearn Mixin or sklearn's BaseEstimator
+
+    dataset: dataset dict
+        Dictionary with keys "classification" and/or "regression"
+        Value must be a list of object which yield X, y array
+        objects when called, ideally using a lambda or
+        functools.partial.
+
+    sparse: bool (default False)
+        Convert X data to a scipy.sparse csr_matrix format.
+
+    queue: SYCL queue or None
+        Queue necessary for device offloading following the
+        SYCL 2020 standard, usually generated by dpctl.
+
+    target_df: string or None
+        dataframe type for returned dataset, as dictated by
+        onedal's _convert_to_dataframe.
+
+    dtype: numpy dtype or None
+       target datatype for returned datasets (see DTYPES).
+
+    Returns
+    -------
+    list of 2-element list X,y: (array-like, array-like)
+        list of datasets for analysis
+    """
+    dataset_type = _gen_dataset_type(est)
+    output = []
     # load data
-    if dataset == "classification" or dataset is None:
-        X, y = load_iris(return_X_y=True)
-    elif dataset == "regression":
-        X, y = load_diabetes(return_X_y=True)
-    else:
-        raise ValueError("Unknown dataset type")
+    flag = dtype is None
+
+    for func in datasets[dataset_type]:
+        X, y = func()
+        if flag:
+            dtype = X.dtype if hasattr(X, "dtype") else np.float64
 
-    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
-    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
-    return X, y
+        if sparse:
+            X = sp.csr_matrix(X)
+        else:
+            X = _convert_to_dataframe(
+                X, sycl_queue=queue, target_df=target_df, dtype=dtype
+            )
+            y = _convert_to_dataframe(
+                y, sycl_queue=queue, target_df=target_df, dtype=dtype
+            )
+        output += [[X, y]]
+    return output
 
 
 DTYPES = [

sklearnex/tests/_utils_spmd.py

@@ -0,0 +1,185 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numpy as np
+from numpy.testing import assert_allclose
+from sklearn.datasets import make_blobs, make_classification, make_regression
+from sklearn.model_selection import train_test_split
+
+from onedal.tests.utils._dataframes_support import _as_numpy
+
+try:
+    import dpctl
+    from dpctl import SyclQueue
+    from mpi4py import MPI
+
+    mpi_libs_available = True
+    gpu_is_available = dpctl.has_gpu_devices()
+except (ImportError, ModuleNotFoundError):
+    mpi_libs_available = False
+
+_mpi_libs_and_gpu_available = mpi_libs_available and gpu_is_available
+
+
+def _get_local_tensor(full_data):
+    """Splits data across ranks.
+
+    Called on each rank to extract the subset of data assigned to that rank.
+
+    Args:
+        full_data (numpy or dpctl array): The entire set of data
+
+    Returns:
+        local_data (numpy or dpctl array): The subset of data used by the rank
+    """
+
+    # create sycl queue and gather communicator details
+    q = SyclQueue("gpu")
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+    size = comm.Get_size()
+
+    # divide data across ranks and move to dpt tensor
+    data_rows = full_data.shape[0]
+    local_start = rank * data_rows // size
+    local_end = (1 + rank) * data_rows // size
+    local_data = full_data[local_start:local_end]
+
+    return local_data
+
+
+def _generate_regression_data(n_samples, n_features, dtype=np.float64, random_state=42):
+    # Generates regression data and divides between train and test
+    X, y = make_regression(
+        n_samples=n_samples, n_features=n_features, random_state=random_state
+    )
+    X = X.astype(dtype)
+    y = y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=random_state)
+    return X_train, X_test, y_train, y_test
+
+
+def _generate_classification_data(
+    n_samples, n_features, n_classes=2, dtype=np.float64, random_state=42
+):
+    # Generates classification data and divides between train and test
+    X, y = make_classification(
+        n_samples=n_samples,
+        n_features=n_features,
+        n_classes=n_classes,
+        n_informative=int(0.5 * n_classes + 1),
+        random_state=random_state,
+    )
+    X = X.astype(dtype)
+    y = y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=random_state)
+    return X_train, X_test, y_train, y_test
+
+
+def _generate_statistic_data(n_samples, n_features, dtype=np.float64, random_state=42):
+    # Generates statistical data
+    gen = np.random.default_rng(random_state)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(n_samples, n_features)).astype(dtype)
+    return data
+
+
+def _generate_clustering_data(
+    n_samples, n_features, centers=None, dtype=np.float64, random_state=42
+):
+    # Generates clustering data and divides between train and test
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        centers=centers,
+        n_features=n_features,
+        random_state=random_state,
+    )
+    X = X.astype(dtype)
+    X_train, X_test = train_test_split(X, random_state=random_state)
+    return X_train, X_test
+
+
+def _spmd_assert_allclose(spmd_result, batch_result, **kwargs):
+    """Calls assert_allclose on spmd and batch results.
+
+    Called on each rank to compare the spmd result specific to that rank and
+    subset of batch result that corresponds to that rank.
+
+    Args:
+        spmd_result (numpy or dpctl array): The result for the subset of data on the rank the function is called from, computed by the spmd estimator
+        batch_result (numpy array): The result for all data, computed by the batch estimator
+
+    Raises:
+        AssertionError: If all results are not adequately close.
+    """
+
+    # extract chunk from batch result to match with local spmd result
+    local_batch_result = _get_local_tensor(batch_result)
+
+    assert_allclose(_as_numpy(spmd_result), _as_numpy(local_batch_result), **kwargs)
+
+
+def _assert_unordered_allclose(spmd_result, batch_result, localize=False, **kwargs):
+    """Checks if rows in spmd and batch results are aligned, even if not in the same order.
+
+    Called to verify correct unordered results are present. Useful to check KMeans centers
+    or KNN neighbors, where order does not matter. Sorts inputs to handle unordering. Also
+    capable of handling localization.
+
+    Args:
+        spmd_result (numpy or dpctl array): Result computed by the spmd estimator
+        batch_result (numpy array): Result computed by batch estimator
+        localize (bool): Whether of not spmd result is specific to the rank, in which case batch result needs to be localized
+
+    Raises:
+        AssertionError: If results do not match.
+    """
+
+    sorted_spmd_result = spmd_result[np.argsort(np.linalg.norm(spmd_result, axis=1))]
+    if localize:
+        local_batch_result = _get_local_tensor(batch_result)
+        sorted_batch_result = local_batch_result[
+            np.argsort(np.linalg.norm(local_batch_result, axis=1))
+        ]
+    else:
+        sorted_batch_result = batch_result[
+            np.argsort(np.linalg.norm(batch_result, axis=1))
+        ]
+
+    assert_allclose(_as_numpy(sorted_spmd_result), sorted_batch_result, **kwargs)
+
+
+def _assert_kmeans_labels_allclose(
+    spmd_labels, batch_labels, spmd_centers, batch_centers, **kwargs
+):
+    """Checks if labels for spmd and batch results are aligned, even cluster indices don't match.
+
+    Called to verify labels are assigned the same way on spmd and batch. Uses raw labels (which
+    may not match) to identify cluster center and ensure results match.
+
+    Args:
+        spmd_labels (numpy or dpctl array): The labels for the subset of data on the rank the function is called from, computed by the spmd estimator
+        batch_labels (numpy array): The labels for all data, computed by the batch estimator
+        spmd_centers (numpy or dpctl array): Centers computed by the spmd estimator
+        batch_centers (numpy array): Centers computed by batch estimator
+
+    Raises:
+        AssertionError: If clusters are not correctly assigned.
+    """
+
+    local_batch_labels = _get_local_tensor(batch_labels)
+    assert_allclose(
+        spmd_centers[_as_numpy(spmd_labels)], batch_centers[local_batch_labels], **kwargs
+    )