scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/neighbors/tests/test_knn_classification.py

@@ -0,0 +1,49 @@
+# ===============================================================================
+# Copyright 2022 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_array_equal
+from sklearn import datasets
+
+from onedal.neighbors import KNeighborsClassifier
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_iris(queue):
+    iris = datasets.load_iris()
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
+    assert clf.score(iris.data, iris.target, queue=queue) > 0.9
+    assert_array_equal(clf.classes_, np.sort(clf.classes_))
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("KNN classifier pickling for the GPU sycl_queue is buggy.")
+    iris = datasets.load_iris()
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
+    expected = clf.predict(iris.data, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(clf)
+    clf2 = pickle.loads(dump)
+
+    assert type(clf2) == clf.__class__
+    result = clf2.predict(iris.data, queue=queue)
+    assert_array_equal(expected, result)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/primitives/__init__.py

@@ -0,0 +1,27 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+from .get_tree import get_tree_state_cls, get_tree_state_reg
+from .kernel_functions import linear_kernel, poly_kernel, rbf_kernel, sigmoid_kernel
+
+__all__ = [
+    "get_tree_state_cls",
+    "get_tree_state_reg",
+    "linear_kernel",
+    "rbf_kernel",
+    "poly_kernel",
+    "sigmoid_kernel",
+]

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/primitives/get_tree.py

@@ -0,0 +1,27 @@
+# ==============================================================================
+# Copyright 2023 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.
+# ==============================================================================
+
+from onedal import _default_backend, _dpc_backend
+
+backend = _dpc_backend or _default_backend
+
+
+def get_tree_state_cls(model, iTree, n_classes):
+    return backend.get_tree.classification.get_tree_state(model, iTree, n_classes)
+
+
+def get_tree_state_reg(model, iTree, n_classes):
+    return backend.get_tree.regression.get_tree_state(model, iTree, n_classes)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/primitives/kernel_functions.py

@@ -0,0 +1,202 @@
+# ===============================================================================
+# Copyright 2021 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 onedal import _default_backend as backend
+from onedal._device_offload import supports_queue
+from onedal.common._backend import BackendFunction
+from onedal.utils import _sycl_queue_manager as QM
+
+from ..datatypes import from_table, to_table
+from ..utils.validation import _check_array
+
+
+def _check_inputs(X, Y):
+    def check_input(data):
+        return _check_array(data, dtype=[np.float64, np.float32], force_all_finite=False)
+
+    X = check_input(X)
+    Y = X if Y is None else check_input(Y)
+    return X, Y
+
+
+def _compute_kernel(params, submodule, X, Y):
+    # get policy for direct backend calls
+
+    queue = QM.get_global_queue()
+    X, Y = to_table(X, Y, queue=queue)
+    params["fptype"] = X.dtype
+    compute_method = BackendFunction(
+        submodule.compute, backend, "compute", no_policy=False
+    )
+    result = compute_method(params, X, Y)
+    return from_table(result.values)
+
+
+@supports_queue
+def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
+    """Compute the linear kernel between X and Y.
+
+    K(x, y) = scale*dot(x, y^T) + shift
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
+    Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    scale : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    shift : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Scaled and shifted Gram matrix output.
+    """
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": scale, "shift": shift},
+        backend.linear_kernel,
+        X,
+        Y,
+    )
+
+
+@supports_queue
+def rbf_kernel(X, Y=None, gamma=None, queue=None):
+    """Compute the rbf (gaussian) kernel between X and Y.
+
+    K(x, y) = exp(-gamma ||x-y||^2)
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
+    Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=None
+        If None, defaults to 1.0 / n_features.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The RBF kernel.
+    """
+
+    X, Y = _check_inputs(X, Y)
+
+    gamma = 1.0 / X.shape[1] if gamma is None else gamma
+    sigma = np.sqrt(0.5 / gamma)
+
+    return _compute_kernel({"method": "dense", "sigma": sigma}, backend.rbf_kernel, X, Y)
+
+
+@supports_queue
+def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
+    """Compute the polynomial kernel between X and Y.
+
+    K(x, y) = (gamma*dot(x, y^T) + coef0)**degree
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
+    Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    degree : int, default=3
+        Kernel degree.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The polynomial kernel.
+    """
+
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": gamma, "shift": coef0, "degree": degree},
+        backend.polynomial_kernel,
+        X,
+        Y,
+    )
+
+
+@supports_queue
+def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
+    """Compute the sigmoid kernel between X and Y.
+
+        :math:`K(x, y) = \\text{tanh}(\\gamma \\mathbf{x}^T \\mathbf{y}) + \\text{coef}_0)`
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
+    Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Sigmoid kernel between two arrays.
+    """
+
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": gamma, "shift": coef0}, backend.sigmoid_kernel, X, Y
+    )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/primitives/tests/test_kernel_functions.py

@@ -0,0 +1,159 @@
+# ==============================================================================
+# Copyright 2021 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 sklearn.metrics.pairwise import rbf_kernel as sklearn_rbf_kernel
+
+from onedal.primitives import linear_kernel, poly_kernel, rbf_kernel, sigmoid_kernel
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_linear_kernel(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Linear kernel for the GPU sycl_queue is buggy.")
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)))
+
+    result = linear_kernel(X, queue=queue)
+    expected = np.dot(X, np.array(X).T)
+    assert_allclose(result, expected, rtol=1e-15)
+
+
+def _test_dense_small_linear_kernel(queue, scale, shift, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(5 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = linear_kernel(X, Y, scale=scale, shift=shift, queue=queue)
+    expected = np.dot(X, np.array(Y).T) * scale + shift
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-6
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("scale", [1.0, 2.0])
+@pytest.mark.parametrize("shift", [0.0, 1.0])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_linear_kernel(queue, scale, shift, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Linear kernel for the GPU sycl_queue is buggy.")
+    _test_dense_small_linear_kernel(queue, scale, shift, dtype)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_rbf_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)))
+
+    result = rbf_kernel(X, queue=queue)
+    expected = sklearn_rbf_kernel(X)
+
+    tol = 1e-5 if result.dtype == np.float32 else 1e-14
+    assert_allclose(result, expected, rtol=tol)
+
+
+def _test_dense_small_rbf_kernel(queue, gamma, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(5 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = rbf_kernel(X, Y, gamma=gamma, queue=queue)
+    expected = sklearn_rbf_kernel(X, Y, gamma)
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-5
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pytest.mark.parametrize("gamma", [0.1, None])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_small_rbf_kernel(queue, gamma, dtype):
+    _test_dense_small_rbf_kernel(queue, gamma, dtype)
+
+
+@pass_if_not_implemented_for_gpu(reason="Polynomial kernel is not implemented for GPU")
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_poly_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)))
+
+    degree = 2
+    result = poly_kernel(X, degree=degree, queue=queue)
+    expected = np.dot(X, np.array(X).T) ** degree
+
+    assert_allclose(result, expected, rtol=1e-14)
+
+
+def _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(2 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = poly_kernel(X, Y, gamma=gamma, coef0=coef0, degree=degree, queue=queue)
+    expected = (gamma * np.dot(X, np.array(Y).T) + coef0) ** degree
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-5
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pass_if_not_implemented_for_gpu(reason="Polynomial kernel is not implemented for GPU")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", [0.1, 1.0])
+@pytest.mark.parametrize("coef0", [0.0, 1.0])
+@pytest.mark.parametrize("degree", [2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
+    _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype)
+
+
+@pass_if_not_implemented_for_gpu(reason="Sigmoid kernel is not implemented for GPU")
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_sigmoid_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((15, 4)))
+
+    result = sigmoid_kernel(X, queue=queue)
+    expected = np.tanh(np.dot(X, np.array(X).T))
+
+    assert_allclose(result, expected)
+
+
+def _test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(2 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = sigmoid_kernel(X, Y, gamma=gamma, coef0=coef0, queue=queue)
+    expected = np.tanh(gamma * np.dot(X, np.array(Y).T) + coef0)
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-6
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pass_if_not_implemented_for_gpu(reason="Sigmoid kernel is not implemented for GPU")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", [0.1, 1.0, 2.4])
+@pytest.mark.parametrize("coef0", [0.0, 1.0, 5.5])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype):
+    _test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/svm/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+from .svm import SVC, SVR, NuSVC, NuSVR, SVMtype
+
+__all__ = ["SVC", "SVR", "NuSVC", "NuSVR", "SVMtype"]