scikit-learn-intelex 2024.4.0__py312-none-manylinux1_x86_64.whl → 2024.6.0__py312-none-manylinux1_x86_64.whl

sklearnex/preview/decomposition/tests/test_incremental_pca.py

@@ -0,0 +1,266 @@
+# ===============================================================================
+# 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 daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.preview.decomposition import IncrementalPCA
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import(dataframe, queue):
+    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    incpca = IncrementalPCA(n_components=2)
+    result = incpca.fit(X)
+    assert "sklearnex" in incpca.__module__
+    assert hasattr(incpca, "_onedal_estimator")
+    assert_allclose(_as_numpy(result.singular_values_), [6.30061232, 0.54980396])
+
+
+def check_pca_on_gold_data(incpca, dtype, whiten, transformed_data):
+    expected_n_samples_seen_ = 6
+    expected_n_features_in_ = 2
+    expected_n_components_ = 2
+    expected_components_ = np.array([[0.83849224, 0.54491354], [-0.54491354, 0.83849224]])
+    expected_singular_values_ = np.array([6.30061232, 0.54980396])
+    expected_mean_ = np.array([0, 0])
+    expected_var_ = np.array([5.6, 2.4])
+    expected_explained_variance_ = np.array([7.93954312, 0.06045688])
+    expected_explained_variance_ratio_ = np.array([0.99244289, 0.00755711])
+    expected_noise_variance_ = 0.0
+    expected_transformed_data = (
+        np.array(
+            [
+                [-0.49096647, -1.19399271],
+                [-0.78854479, 1.02218579],
+                [-1.27951125, -0.17180692],
+                [0.49096647, 1.19399271],
+                [0.78854479, -1.02218579],
+                [1.27951125, 0.17180692],
+            ]
+        )
+        if whiten
+        else np.array(
+            [
+                [-1.38340578, -0.2935787],
+                [-2.22189802, 0.25133484],
+                [-3.6053038, -0.04224385],
+                [1.38340578, 0.2935787],
+                [2.22189802, -0.25133484],
+                [3.6053038, 0.04224385],
+            ]
+        )
+    )
+
+    tol = 1e-7
+    if transformed_data.dtype == np.float32:
+        tol = 7e-6 if whiten else 1e-6
+
+    assert incpca.n_samples_seen_ == expected_n_samples_seen_
+    assert incpca.n_features_in_ == expected_n_features_in_
+    assert incpca.n_components_ == expected_n_components_
+
+    assert_allclose(incpca.singular_values_, expected_singular_values_, atol=tol)
+    assert_allclose(incpca.mean_, expected_mean_, atol=tol)
+    assert_allclose(incpca.var_, expected_var_, atol=tol)
+    assert_allclose(incpca.explained_variance_, expected_explained_variance_, atol=tol)
+    assert_allclose(
+        incpca.explained_variance_ratio_, expected_explained_variance_ratio_, atol=tol
+    )
+    assert np.abs(incpca.noise_variance_ - expected_noise_variance_) < tol
+    if daal_check_version((2024, "P", 500)):
+        assert_allclose(incpca.components_, expected_components_, atol=tol)
+        assert_allclose(_as_numpy(transformed_data), expected_transformed_data, atol=tol)
+    else:
+        for i in range(incpca.n_components_):
+            abs_dot_product = np.abs(
+                np.dot(incpca.components_[i], expected_components_[i])
+            )
+            assert np.abs(abs_dot_product - 1.0) < tol
+
+            if np.dot(incpca.components_[i], expected_components_[i]) < 0:
+                assert_allclose(
+                    _as_numpy(-transformed_data[i]),
+                    expected_transformed_data[i],
+                    atol=tol,
+                )
+            else:
+                assert_allclose(
+                    _as_numpy(transformed_data[i]), expected_transformed_data[i], atol=tol
+                )
+
+
+def check_pca(incpca, dtype, whiten, data, transformed_data):
+    tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
+
+    n_components = incpca.n_components_
+
+    expected_n_samples_seen = data.shape[0]
+    expected_n_features_in = data.shape[1]
+    n_samples_seen = incpca.n_samples_seen_
+    n_features_in = incpca.n_features_in_
+    assert n_samples_seen == expected_n_samples_seen
+    assert n_features_in == expected_n_features_in
+
+    components = incpca.components_
+    singular_values = incpca.singular_values_
+    centered_data = data - np.mean(data, axis=0)
+    cov_eigenvalues, cov_eigenvectors = np.linalg.eig(
+        centered_data.T @ centered_data / (n_samples_seen - 1)
+    )
+    cov_eigenvalues = np.nan_to_num(cov_eigenvalues)
+    cov_eigenvalues[cov_eigenvalues < 0] = 0
+    eigenvalues_order = np.argsort(cov_eigenvalues)[::-1]
+    sorted_eigenvalues = cov_eigenvalues[eigenvalues_order]
+    sorted_eigenvectors = cov_eigenvectors[:, eigenvalues_order]
+    expected_singular_values = np.sqrt(sorted_eigenvalues * (n_samples_seen - 1))[
+        :n_components
+    ]
+    expected_components = sorted_eigenvectors.T[:n_components]
+
+    assert_allclose(singular_values, expected_singular_values, atol=tol)
+    for i in range(n_components):
+        component_length = np.dot(components[i], components[i])
+        assert np.abs(component_length - 1.0) < tol
+        abs_dot_product = np.abs(np.dot(components[i], expected_components[i]))
+        assert np.abs(abs_dot_product - 1.0) < tol
+
+    expected_mean = np.mean(data, axis=0)
+    assert_allclose(incpca.mean_, expected_mean, atol=tol)
+
+    expected_var = np.var(_as_numpy(data), ddof=1, axis=0)
+    assert_allclose(incpca.var_, expected_var, atol=tol)
+
+    expected_explained_variance = sorted_eigenvalues[:n_components]
+    assert_allclose(incpca.explained_variance_, expected_explained_variance, atol=tol)
+
+    expected_explained_variance_ratio = expected_explained_variance / np.sum(
+        sorted_eigenvalues
+    )
+    assert_allclose(
+        incpca.explained_variance_ratio_, expected_explained_variance_ratio, atol=tol
+    )
+
+    expected_noise_variance = (
+        np.mean(sorted_eigenvalues[n_components:])
+        if len(sorted_eigenvalues) > n_components
+        else 0.0
+    )
+    # TODO Fix noise variance computation (It is necessary to update C++ side)
+    # assert np.abs(incpca.noise_variance_ - expected_noise_variance) < tol
+
+    expected_transformed_data = centered_data @ components.T
+    if whiten:
+        scale = np.sqrt(incpca.explained_variance_)
+        min_scale = np.finfo(scale.dtype).eps
+        scale[scale < min_scale] = np.inf
+        expected_transformed_data /= scale
+
+    if not (whiten and n_components == n_samples_seen):
+        assert_allclose(_as_numpy(transformed_data), expected_transformed_data, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_partial_fit_on_gold_data(dataframe, queue, whiten, num_blocks, dtype):
+
+    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_blocks)
+    incpca = IncrementalPCA(whiten=whiten)
+
+    for i in range(num_blocks):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        incpca.partial_fit(X_split_df)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    transformed_data = incpca.transform(X_df)
+    check_pca_on_gold_data(incpca, dtype, whiten, transformed_data)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_fit_on_gold_data(dataframe, queue, whiten, num_blocks, dtype):
+
+    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    X = X.astype(dtype=dtype)
+    incpca = IncrementalPCA(whiten=whiten, batch_size=X.shape[0] // num_blocks)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    incpca.fit(X_df)
+    transformed_data = incpca.transform(X_df)
+
+    check_pca_on_gold_data(incpca, dtype, whiten, transformed_data)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_fit_transform_on_gold_data(
+    dataframe, queue, whiten, num_blocks, dtype
+):
+
+    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    X = X.astype(dtype=dtype)
+    incpca = IncrementalPCA(whiten=whiten, batch_size=X.shape[0] // num_blocks)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    transformed_data = incpca.fit_transform(X_df)
+
+    check_pca_on_gold_data(incpca, dtype, whiten, transformed_data)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("n_components", [None, 1, 5])
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_partial_fit_on_random_data(
+    dataframe, queue, n_components, whiten, num_blocks, row_count, column_count, dtype
+):
+    seed = 81
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_blocks)
+    incpca = IncrementalPCA(n_components=n_components, whiten=whiten)
+
+    for i in range(num_blocks):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        incpca.partial_fit(X_split_df)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    transformed_data = incpca.transform(X_df)
+    check_pca(incpca, dtype, whiten, X, transformed_data)

sklearnex/svm/_common.py

@@ -15,15 +15,20 @@
 # ==============================================================================
 
 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.metrics import r2_score
 from sklearn.model_selection import StratifiedKFold
 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):
@@ -105,22 +235,31 @@ class BaseSVC(BaseSVM):
         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
-            )
-            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)
+        # 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):
+            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
+                )
+                self.clf_prob = CalibratedClassifierCV(
+                    clf_base,
+                    ensemble=False,
+                    cv=cv,
+                    method="sigmoid",
+                )
+                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)
 
     def _save_attributes(self):
         self.support_vectors_ = self._onedal_estimator.support_vectors_
@@ -129,7 +268,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 +323,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__