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

sklearnex/spmd/neighbors/tests/test_neighbors_spmd.py

@@ -0,0 +1,288 @@
+# ==============================================================================
+# 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
+import pytest
+from numpy.testing import assert_allclose
+
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests._utils_spmd import (
+    _assert_unordered_allclose,
+    _generate_classification_data,
+    _generate_regression_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+    _spmd_assert_allclose,
+)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_knncls_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.neighbors import KNeighborsClassifier as KNeighborsClassifier_Batch
+    from sklearnex.spmd.neighbors import KNeighborsClassifier as KNeighborsClassifier_SPMD
+
+    # Create gold data and convert to dataframe
+    X_train = np.array(
+        [
+            [0.0, 0.0],
+            [0.0, 1.0],
+            [1.0, 0.0],
+            [0.0, 2.0],
+            [2.0, 0.0],
+            [0.9, 1.0],
+            [0.0, -1.0],
+            [-1.0, 0.0],
+            [-1.0, -1.0],
+        ]
+    )
+    # TODO: handle situations where not all classes are present on all ranks?
+    y_train = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0])
+    X_test = np.array(
+        [
+            [1.0, -0.5],
+            [-5.0, 1.0],
+            [0.0, 1.0],
+            [10.0, -10.0],
+        ]
+    )
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_y_train = _convert_to_dataframe(
+        _get_local_tensor(y_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure predictions of batch algo match spmd
+    spmd_model = KNeighborsClassifier_SPMD(n_neighbors=1, algorithm="brute").fit(
+        local_dpt_X_train, local_dpt_y_train
+    )
+    batch_model = KNeighborsClassifier_Batch(n_neighbors=1, algorithm="brute").fit(
+        X_train, y_train
+    )
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_test)
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
+    _assert_unordered_allclose(spmd_dists, batch_dists, localize=True)
+    _spmd_assert_allclose(spmd_result, batch_result)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [200, 10000])
+@pytest.mark.parametrize("n_features_and_classes", [(5, 2), (25, 2), (25, 10)])
+@pytest.mark.parametrize("n_neighbors", [1, 5, 20])
+@pytest.mark.parametrize("weights", ["uniform", "distance"])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_knncls_spmd_synthetic(
+    n_samples,
+    n_features_and_classes,
+    n_neighbors,
+    weights,
+    dataframe,
+    queue,
+    dtype,
+    metric="euclidean",
+):
+    n_features, n_classes = n_features_and_classes
+    # Import spmd and batch algo
+    from sklearnex.neighbors import KNeighborsClassifier as KNeighborsClassifier_Batch
+    from sklearnex.spmd.neighbors import KNeighborsClassifier as KNeighborsClassifier_SPMD
+
+    # Generate data and convert to dataframe
+    X_train, X_test, y_train, _ = _generate_classification_data(
+        n_samples, n_features, n_classes, dtype=dtype
+    )
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_y_train = _convert_to_dataframe(
+        _get_local_tensor(y_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure predictions of batch algo match spmd
+    spmd_model = KNeighborsClassifier_SPMD(
+        n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
+    ).fit(local_dpt_X_train, local_dpt_y_train)
+    batch_model = KNeighborsClassifier_Batch(
+        n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
+    ).fit(X_train, y_train)
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_test)
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    tol = 1e-4
+    if dtype == np.float64:
+        _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
+        _assert_unordered_allclose(
+            spmd_dists, batch_dists, localize=True, rtol=tol, atol=tol
+        )
+    _spmd_assert_allclose(spmd_result, batch_result)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_knnreg_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.neighbors import KNeighborsRegressor as KNeighborsRegressor_Batch
+    from sklearnex.spmd.neighbors import KNeighborsRegressor as KNeighborsRegressor_SPMD
+
+    # Create gold data and convert to dataframe
+    X_train = np.array(
+        [
+            [0.0, 0.0],
+            [0.0, 1.0],
+            [1.0, 0.0],
+            [0.0, 2.0],
+            [2.0, 0.0],
+            [1.0, 1.0],
+            [0.0, -1.0],
+            [-1.0, 0.0],
+            [-1.0, -1.0],
+        ]
+    )
+    y_train = np.array([3.0, 5.0, 4.0, 7.0, 5.0, 6.0, 1.0, 2.0, 0.0])
+    X_test = np.array(
+        [
+            [1.0, -0.5],
+            [-5.0, 1.0],
+            [0.0, 1.0],
+            [10.0, -10.0],
+        ]
+    )
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_y_train = _convert_to_dataframe(
+        _get_local_tensor(y_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure predictions of batch algo match spmd
+    spmd_model = KNeighborsRegressor_SPMD(n_neighbors=1, algorithm="brute").fit(
+        local_dpt_X_train, local_dpt_y_train
+    )
+    batch_model = KNeighborsRegressor_Batch(n_neighbors=1, algorithm="brute").fit(
+        X_train, y_train
+    )
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_test)
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
+    _assert_unordered_allclose(spmd_dists, batch_dists, localize=True)
+    _spmd_assert_allclose(spmd_result, batch_result)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [200, 10000])
+@pytest.mark.parametrize("n_features", [5, 25])
+@pytest.mark.parametrize("n_neighbors", [1, 5, 20])
+@pytest.mark.parametrize("weights", ["uniform", "distance"])
+@pytest.mark.parametrize(
+    "metric", ["euclidean", "manhattan", "minkowski", "chebyshev", "cosine"]
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_knnreg_spmd_synthetic(
+    n_samples, n_features, n_neighbors, weights, metric, dataframe, queue, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.neighbors import KNeighborsRegressor as KNeighborsRegressor_Batch
+    from sklearnex.spmd.neighbors import KNeighborsRegressor as KNeighborsRegressor_SPMD
+
+    # Generate data and convert to dataframe
+    X_train, X_test, y_train, _ = _generate_regression_data(
+        n_samples, n_features, dtype=dtype
+    )
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_y_train = _convert_to_dataframe(
+        _get_local_tensor(y_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure predictions of batch algo match spmd
+    spmd_model = KNeighborsRegressor_SPMD(
+        n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
+    ).fit(local_dpt_X_train, local_dpt_y_train)
+    batch_model = KNeighborsRegressor_Batch(
+        n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
+    ).fit(X_train, y_train)
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_test)
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    tol = 0.005 if dtype == np.float32 else 1e-4
+    if dtype == np.float64:
+        _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
+        _assert_unordered_allclose(
+            spmd_dists, batch_dists, localize=True, rtol=tol, atol=tol
+        )
+    _spmd_assert_allclose(spmd_result, batch_result, rtol=tol, atol=tol)

sklearnex/svm/_common.py

@@ -14,16 +14,21 @@
 # limitations under the License.
 # ==============================================================================
 
+import warnings
 from abc import ABC
+from numbers import Number, Real
 
 import numpy as np
+from scipy import sparse as sp
+from sklearn.base import BaseEstimator, ClassifierMixin
 from sklearn.calibration import CalibratedClassifierCV
-from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import r2_score
 from sklearn.preprocessing import LabelEncoder
 
 from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils import _column_or_1d
+from onedal.utils import _check_array, _check_X_y, _column_or_1d
 
+from .._config import config_context, get_config
 from .._utils import PatchingConditionsChain
 
 
@@ -51,7 +56,8 @@ def set_intercept(self, value):
             del self._onedal_estimator._onedal_model
 
 
-class BaseSVM(ABC):
+class BaseSVM(BaseEstimator, ABC):
+
     def _onedal_gpu_supported(self, method_name, *data):
         patching_status = PatchingConditionsChain(f"sklearn.{method_name}")
         patching_status.and_conditions([(False, "GPU offloading is not supported.")])
@@ -74,7 +80,7 @@ class BaseSVM(ABC):
             )
             return patching_status
         inference_methods = (
-            ["predict"]
+            ["predict", "score"]
             if class_name.endswith("R")
             else ["predict", "predict_proba", "decision_function", "score"]
         )
@@ -85,6 +91,130 @@ class BaseSVM(ABC):
             return patching_status
         raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
+    def _compute_gamma_sigma(self, X):
+        # only run extended conversion if kernel is not linear
+        # set to a value = 1.0, so gamma will always be passed to
+        # the onedal estimator as a float type
+        if self.kernel == "linear":
+            return 1.0
+
+        if isinstance(self.gamma, str):
+            if self.gamma == "scale":
+                if sp.issparse(X):
+                    # var = E[X^2] - E[X]^2
+                    X_sc = (X.multiply(X)).mean() - (X.mean()) ** 2
+                else:
+                    X_sc = X.var()
+                _gamma = 1.0 / (X.shape[1] * X_sc) if X_sc != 0 else 1.0
+            elif self.gamma == "auto":
+                _gamma = 1.0 / X.shape[1]
+            else:
+                raise ValueError(
+                    "When 'gamma' is a string, it should be either 'scale' or "
+                    "'auto'. Got '{}' instead.".format(self.gamma)
+                )
+        else:
+            if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
+                if isinstance(self.gamma, Real):
+                    if self.gamma <= 0:
+                        msg = (
+                            f"gamma value must be > 0; {self.gamma!r} is invalid. Use"
+                            " a positive number or use 'auto' to set gamma to a"
+                            " value of 1 / n_features."
+                        )
+                        raise ValueError(msg)
+                    _gamma = self.gamma
+                else:
+                    msg = (
+                        "The gamma value should be set to 'scale', 'auto' or a"
+                        f" positive float value. {self.gamma!r} is not a valid option"
+                    )
+                    raise ValueError(msg)
+            else:
+                _gamma = self.gamma
+        return _gamma
+
+    def _onedal_fit_checks(self, X, y, sample_weight=None):
+        if hasattr(self, "decision_function_shape"):
+            if self.decision_function_shape not in ("ovr", "ovo", None):
+                raise ValueError(
+                    f"decision_function_shape must be either 'ovr' or 'ovo', "
+                    f"got {self.decision_function_shape}."
+                )
+
+        if y is None:
+            if self._get_tags()["requires_y"]:
+                raise ValueError(
+                    f"This {self.__class__.__name__} estimator "
+                    f"requires y to be passed, but the target y is None."
+                )
+        # using onedal _check_X_y to insure X and y are contiguous
+        # finite check occurs in onedal estimator
+        X, y = _check_X_y(
+            X,
+            y,
+            dtype=[np.float64, np.float32],
+            force_all_finite=False,
+            accept_sparse="csr",
+        )
+        y = self._validate_targets(y)
+        sample_weight = self._get_sample_weight(X, y, sample_weight)
+        return X, y, sample_weight
+
+    def _get_sample_weight(self, X, y, sample_weight):
+        n_samples = X.shape[0]
+        dtype = X.dtype
+        if n_samples == 1:
+            raise ValueError("n_samples=1")
+
+        sample_weight = np.ascontiguousarray(
+            [] if sample_weight is None else sample_weight, dtype=np.float64
+        )
+
+        sample_weight_count = sample_weight.shape[0]
+        if sample_weight_count != 0 and sample_weight_count != n_samples:
+            raise ValueError(
+                "sample_weight and X have incompatible shapes: "
+                "%r vs %r\n"
+                "Note: Sparse matrices cannot be indexed w/"
+                "boolean masks (use `indices=True` in CV)."
+                % (len(sample_weight), X.shape)
+            )
+
+        if sample_weight_count == 0:
+            if not isinstance(self, ClassifierMixin) or self.class_weight_ is None:
+                return None
+            sample_weight = np.ones(n_samples, dtype=dtype)
+        elif isinstance(sample_weight, Number):
+            sample_weight = np.full(n_samples, sample_weight, dtype=dtype)
+        else:
+            sample_weight = _check_array(
+                sample_weight,
+                accept_sparse=False,
+                ensure_2d=False,
+                dtype=dtype,
+                order="C",
+            )
+            if sample_weight.ndim != 1:
+                raise ValueError("Sample weights must be 1D array or scalar")
+
+            if sample_weight.shape != (n_samples,):
+                raise ValueError(
+                    "sample_weight.shape == {}, expected {}!".format(
+                        sample_weight.shape, (n_samples,)
+                    )
+                )
+
+        if np.all(sample_weight <= 0):
+            if "nusvc" in self.__module__:
+                raise ValueError("negative dimensions are not allowed")
+            else:
+                raise ValueError(
+                    "Invalid input - all samples have zero or negative weights."
+                )
+
+        return sample_weight
+
 
 class BaseSVC(BaseSVM):
     def _compute_balanced_class_weight(self, y):
@@ -100,27 +230,34 @@ class BaseSVC(BaseSVM):
         return recip_freq[le.transform(classes)]
 
     def _fit_proba(self, X, y, sample_weight=None, queue=None):
+        # TODO: rewrite this method when probabilities output is implemented in oneDAL
+
+        # LibSVM uses the random seed to control cross-validation for probability generation
+        # CalibratedClassifierCV with "prefit" does not use an RNG nor a seed. This may
+        # impact users without their knowledge, so display a warning.
+        if self.random_state is not None:
+            warnings.warn(
+                "random_state does not influence oneDAL SVM results",
+                RuntimeWarning,
+            )
+
         params = self.get_params()
         params["probability"] = False
         params["decision_function_shape"] = "ovr"
         clf_base = self.__class__(**params)
 
-        try:
-            n_splits = 5
-            n_jobs = n_splits if queue is None or queue.sycl_device.is_cpu else 1
-            cv = StratifiedKFold(
-                n_splits=n_splits, shuffle=True, random_state=self.random_state
-            )
+        # We use stock metaestimators below, so the only way
+        # to pass a queue is using config_context.
+        cfg = get_config()
+        cfg["target_offload"] = queue
+        with config_context(**cfg):
+            clf_base.fit(X, y)
             self.clf_prob = CalibratedClassifierCV(
-                clf_base, ensemble=False, cv=cv, method="sigmoid", n_jobs=n_jobs
-            )
-            self.clf_prob.fit(X, y, sample_weight)
-        except ValueError:
-            clf_base = clf_base.fit(X, y, sample_weight)
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base, cv="prefit", method="sigmoid"
-            )
-            self.clf_prob.fit(X, y, sample_weight)
+                clf_base,
+                ensemble=False,
+                cv="prefit",
+                method="sigmoid",
+            ).fit(X, y)
 
     def _save_attributes(self):
         self.support_vectors_ = self._onedal_estimator.support_vectors_
@@ -129,7 +266,8 @@ class BaseSVC(BaseSVM):
         self.dual_coef_ = self._onedal_estimator.dual_coef_
         self.shape_fit_ = self._onedal_estimator.class_weight_
         self.classes_ = self._onedal_estimator.classes_
-        self.class_weight_ = self._onedal_estimator.class_weight_
+        if isinstance(self, ClassifierMixin) or not sklearn_check_version("1.2"):
+            self.class_weight_ = self._onedal_estimator.class_weight_
         self.support_ = self._onedal_estimator.support_
 
         self._intercept_ = self._onedal_estimator.intercept_
@@ -183,3 +321,8 @@ class BaseSVR(BaseSVM):
 
         if sklearn_check_version("1.1"):
             self.n_iter_ = self._onedal_estimator.n_iter_
+
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return r2_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )

sklearnex/svm/nusvc.py

@@ -83,6 +83,17 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
     def fit(self, X, y, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
+        elif self.nu <= 0 or self.nu > 1:
+            # 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("nu <= 0 or nu > 1")
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
         dispatch(
@@ -94,7 +105,7 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
 
         return self
@@ -242,12 +253,31 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
 
     decision_function.__doc__ = sklearn_NuSVC.decision_function.__doc__
 
+    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
+
+        weight_per_class = [
+            np.sum(sample_weight[y == class_label]) for class_label in np.unique(y)
+        ]
+
+        for i in range(len(weight_per_class)):
+            for j in range(i + 1, len(weight_per_class)):
+                if self.nu * (weight_per_class[i] + weight_per_class[j]) / 2 > min(
+                    weight_per_class[i], weight_per_class[j]
+                ):
+                    raise ValueError("specified nu is infeasible")
+
+        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 = {
             "nu": self.nu,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -259,10 +289,16 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
         }
 
         self._onedal_estimator = onedal_NuSVC(**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/nusvr.py

@@ -65,6 +65,17 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
     def fit(self, X, y, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
+        elif self.nu <= 0 or self.nu > 1:
+            # 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("nu <= 0 or nu > 1")
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
         dispatch(
@@ -76,7 +87,7 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
             },
             X,
             y,
-            sample_weight,
+            sample_weight=sample_weight,
         )
         return self
 
@@ -94,13 +105,30 @@ class NuSVR(sklearn_NuSVR, 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_NuSVR.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,
             "nu": self.nu,
             "kernel": self.kernel,
             "degree": self.degree,
-            "gamma": self.gamma,
+            "gamma": self._compute_gamma_sigma(X),
             "coef0": self.coef0,
             "tol": self.tol,
             "shrinking": self.shrinking,
@@ -117,3 +145,4 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
 
     fit.__doc__ = sklearn_NuSVR.fit.__doc__
     predict.__doc__ = sklearn_NuSVR.predict.__doc__
+    score.__doc__ = sklearn_NuSVR.score.__doc__