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

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/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
+    )

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -0,0 +1,54 @@
+# ==============================================================================
+# 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 os
+from glob import glob
+
+import pytest
+
+ALLOWED_LOCATIONS = [
+    "_config.py",
+    "_device_offload.py",
+    "test",
+    "svc.py",
+    "svm" + os.sep + "_common.py",
+]
+
+
+def test_target_offload_ban():
+    """This test blocks the use of target_offload in
+    in sklearnex files. Offloading computation to devices
+    via target_offload should only occur externally, and not
+    within the architecture of the sklearnex classes. This
+    is for clarity, traceability and maintainability.
+    """
+    from sklearnex import __file__ as loc
+
+    path = loc.replace("__init__.py", "")
+    files = [y for x in os.walk(path) for y in glob(os.path.join(x[0], "*.py"))]
+
+    output = []
+
+    for f in files:
+        if open(f, "r").read().find("target_offload") != -1:
+            output += [f.replace(path, "sklearnex" + os.sep)]
+
+    # remove this file from the list
+    for allowed in ALLOWED_LOCATIONS:
+        output = [i for i in output if allowed not in i]
+
+    output = "\n".join(output)
+    assert output == "", f"sklearn versioning is occuring in: \n{output}"

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.7.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -16,6 +16,7 @@
 
 import sklearn
 
+import onedal
 import sklearnex
 
 
@@ -33,7 +34,10 @@ def test_set_config_works():
     )
 
     config = sklearnex.get_config()
+    onedal_config = onedal._config._get_config()
     assert config["target_offload"] == "cpu:0"
     assert config["allow_fallback_to_host"]
     assert config["assume_finite"]
+    assert onedal_config["target_offload"] == "cpu:0"
+    assert onedal_config["allow_fallback_to_host"]
     sklearnex.set_config(**default_config)

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -0,0 +1,290 @@
+# ==============================================================================
+# 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 gc
+import logging
+import os
+import tracemalloc
+import types
+import warnings
+from inspect import isclass
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy.stats import pearsonr
+from sklearn.base import BaseEstimator, clone
+from sklearn.datasets import make_classification
+from sklearn.model_selection import KFold
+
+from onedal import _is_dpc_backend
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from onedal.tests.utils._device_selection import get_queues, is_dpctl_available
+from sklearnex import config_context
+from sklearnex.tests._utils import PATCHED_FUNCTIONS, PATCHED_MODELS, SPECIAL_INSTANCES
+from sklearnex.utils import get_namespace
+
+if _is_dpc_backend:
+    from onedal import _backend
+
+
+CPU_SKIP_LIST = (
+    "TSNE",  # too slow for using in testing on common data size
+    "config_context",  # does not malloc
+    "get_config",  # does not malloc
+    "set_config",  # does not malloc
+    "SVC(probability=True)",  # memory leak fortran numpy (investigate _fit_proba)
+    "NuSVC(probability=True)",  # memory leak fortran numpy (investigate _fit_proba)
+    "IncrementalEmpiricalCovariance",  # dataframe_f issues
+    "IncrementalLinearRegression",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
+    "IncrementalPCA",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
+    "LogisticRegression(solver='newton-cg')",  # memory leak fortran (1000, 100)
+)
+
+GPU_SKIP_LIST = (
+    "TSNE",  # too slow for using in testing on common data size
+    "RandomForestRegressor",  # too slow for using in testing on common data size
+    "KMeans",  # does not support GPU offloading
+    "config_context",  # does not malloc
+    "get_config",  # does not malloc
+    "set_config",  # does not malloc
+    "Ridge",  # does not support GPU offloading (fails silently)
+    "ElasticNet",  # does not support GPU offloading (fails silently)
+    "Lasso",  # does not support GPU offloading (fails silently)
+    "SVR",  # does not support GPU offloading (fails silently)
+    "NuSVR",  # does not support GPU offloading (fails silently)
+    "NuSVC",  # does not support GPU offloading (fails silently)
+    "LogisticRegression",  # default parameters not supported, see solver=newton-cg
+    "NuSVC(probability=True)",  # does not support GPU offloading (fails silently)
+    "IncrementalLinearRegression",  # issue with potrf with the specific dataset
+    "LinearRegression",  # issue with potrf with the specific dataset
+)
+
+
+def gen_functions(functions):
+    func_dict = functions.copy()
+
+    roc_auc_score = func_dict.pop("roc_auc_score")
+    func_dict["roc_auc_score"] = lambda x, y: roc_auc_score(y, y)
+
+    pairwise_distances = func_dict.pop("pairwise_distances")
+    func_dict["pairwise_distances(metric='cosine')"] = lambda x, y: pairwise_distances(
+        x, metric="cosine"
+    )
+    func_dict["pairwise_distances(metric='correlation')"] = (
+        lambda x, y: pairwise_distances(x, metric="correlation")
+    )
+
+    _assert_all_finite = func_dict.pop("_assert_all_finite")
+    func_dict["_assert_all_finite"] = lambda x, y: [
+        _assert_all_finite(x),
+        _assert_all_finite(y),
+    ]
+    return func_dict
+
+
+FUNCTIONS = gen_functions(PATCHED_FUNCTIONS)
+
+CPU_ESTIMATORS = {
+    k: v
+    for k, v in {**PATCHED_MODELS, **SPECIAL_INSTANCES, **FUNCTIONS}.items()
+    if not k in CPU_SKIP_LIST
+}
+
+GPU_ESTIMATORS = {
+    k: v
+    for k, v in {**PATCHED_MODELS, **SPECIAL_INSTANCES}.items()
+    if not k in GPU_SKIP_LIST
+}
+
+data_shapes = [
+    pytest.param((1000, 100), id="(1000, 100)"),
+    pytest.param((2000, 50), id="(2000, 50)"),
+]
+
+EXTRA_MEMORY_THRESHOLD = 0.15
+N_SPLITS = 10
+ORDER_DICT = {"F": np.asfortranarray, "C": np.ascontiguousarray}
+
+
+def gen_clsf_data(n_samples, n_features):
+    data, label = make_classification(
+        n_classes=2, n_samples=n_samples, n_features=n_features, random_state=777
+    )
+    return (
+        data,
+        label,
+        data.size * data.dtype.itemsize + label.size * label.dtype.itemsize,
+    )
+
+
+def get_traced_memory(queue=None):
+    if _is_dpc_backend and queue and queue.sycl_device.is_gpu:
+        return _backend.get_used_memory(queue)
+    else:
+        return tracemalloc.get_traced_memory()[0]
+
+
+def take(x, index, axis=0, queue=None):
+    xp, array_api = get_namespace(x)
+    if array_api:
+        return xp.take(x, xp.asarray(index, device=queue), axis=axis)
+    else:
+        return x.take(index, axis=axis)
+
+
+def split_train_inference(kf, x, y, estimator, queue=None):
+    mem_tracks = []
+    for train_index, test_index in kf.split(x):
+        x_train = take(x, train_index, queue=queue)
+        y_train = take(y, train_index, queue=queue)
+        x_test = take(x, test_index, queue=queue)
+        y_test = take(y, test_index, queue=queue)
+
+        if isclass(estimator) and issubclass(estimator, BaseEstimator):
+            alg = estimator()
+            flag = True
+        elif isinstance(estimator, BaseEstimator):
+            alg = clone(estimator)
+            flag = True
+        else:
+            flag = False
+
+        if flag:
+            alg.fit(x_train, y_train)
+            if hasattr(alg, "predict"):
+                alg.predict(x_test)
+            elif hasattr(alg, "transform"):
+                alg.transform(x_test)
+            elif hasattr(alg, "kneighbors"):
+                alg.kneighbors(x_test)
+            del alg
+        else:
+            estimator(x_train, y_train)
+
+        del x_train, x_test, y_train, y_test, flag
+        mem_tracks.append(get_traced_memory(queue))
+    return mem_tracks
+
+
+def _kfold_function_template(estimator, dataframe, data_shape, queue=None, func=None):
+    tracemalloc.start()
+
+    n_samples, n_features = data_shape
+    X, y, data_memory_size = gen_clsf_data(n_samples, n_features)
+    kf = KFold(n_splits=N_SPLITS)
+    if func:
+        X = func(X)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+
+    mem_before = get_traced_memory(queue)
+    mem_tracks = split_train_inference(kf, X, y, estimator, queue=queue)
+    mem_iter_diffs = np.array(mem_tracks[1:]) - np.array(mem_tracks[:-1])
+    mem_incr_mean, mem_incr_std = mem_iter_diffs.mean(), mem_iter_diffs.std()
+    mem_incr_mean, mem_incr_std = round(mem_incr_mean), round(mem_incr_std)
+    with warnings.catch_warnings():
+        # In the case that the memory usage is constant, this will raise
+        # a ConstantInputWarning error in pearsonr from scipy, this can
+        # be ignored.
+        warnings.filterwarnings(
+            "ignore",
+            message="An input array is constant; the correlation coefficient is not defined",
+        )
+        mem_iter_corr, _ = pearsonr(mem_tracks, list(range(len(mem_tracks))))
+
+    if mem_iter_corr > 0.95:
+        logging.warning(
+            "Memory usage is steadily increasing with iterations "
+            "(Pearson correlation coefficient between "
+            f"memory tracks and iterations is {mem_iter_corr})\n"
+            "Memory usage increase per iteration: "
+            f"{mem_incr_mean}±{mem_incr_std} bytes"
+        )
+    mem_before_gc = get_traced_memory(queue)
+    mem_diff = mem_before_gc - mem_before
+    if isinstance(estimator, BaseEstimator):
+        name = str(estimator)
+    else:
+        name = estimator.__name__
+
+    message = (
+        "Size of extra allocated memory {} using garbage collector "
+        f"is greater than {EXTRA_MEMORY_THRESHOLD * 100}% of input data"
+        f"\n\tAlgorithm: {name}"
+        f"\n\tInput data size: {data_memory_size} bytes"
+        "\n\tExtra allocated memory size: {} bytes"
+        " / {} %"
+    )
+    if mem_diff >= EXTRA_MEMORY_THRESHOLD * data_memory_size:
+        logging.warning(
+            message.format(
+                "before", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
+            )
+        )
+    gc.collect()
+    mem_after = get_traced_memory(queue)
+    tracemalloc.stop()
+    mem_diff = mem_after - mem_before
+
+    # GPU offloading with SYCL contains a program/kernel cache which should
+    # be controllable via a KernelProgramCache object in the SYCL context.
+    # The programs and kernels are stored on the GPU, but cannot be cleared
+    # as this class is not available for access in all oneDAL DPC++ runtimes.
+    # Therefore, until this is implemented this test must be skipped for gpu
+    # as it looks like a memory leak (at least there is no way to discern a
+    # leak on the first run).
+    if queue is None or queue.sycl_device.is_cpu:
+        assert mem_diff < EXTRA_MEMORY_THRESHOLD * data_memory_size, message.format(
+            "after", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
+        )
+
+
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("numpy,pandas,dpctl", "cpu")
+)
+@pytest.mark.parametrize("estimator", CPU_ESTIMATORS.keys())
+@pytest.mark.parametrize("data_shape", data_shapes)
+def test_memory_leaks(estimator, dataframe, queue, order, data_shape):
+    func = ORDER_DICT[order]
+    if estimator == "_assert_all_finite" and queue is not None:
+        pytest.skip(f"{estimator} is not designed for device offloading")
+
+    _kfold_function_template(
+        CPU_ESTIMATORS[estimator], dataframe, data_shape, queue, func
+    )
+
+
+@pytest.mark.skipif(
+    os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_available("gpu"),
+    reason="SYCL device memory leak check requires the level zero sysman",
+)
+@pytest.mark.parametrize("queue", get_queues("gpu"))
+@pytest.mark.parametrize("estimator", GPU_ESTIMATORS.keys())
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+def test_gpu_memory_leaks(estimator, queue, order, data_shape):
+    func = ORDER_DICT[order]
+    if "ExtraTrees" in estimator and data_shape == (2000, 50):
+        pytest.skip("Avoid a segmentation fault in Extra Trees algorithms")
+
+    with config_context(target_offload=queue):
+        _kfold_function_template(GPU_ESTIMATORS[estimator], None, data_shape, queue, func)

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.7.0.data}/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -208,10 +208,11 @@ def test_preview_namespace():
         from sklearn.cluster import DBSCAN
         from sklearn.decomposition import PCA
         from sklearn.ensemble import RandomForestClassifier
-        from sklearn.linear_model import LinearRegression
+        from sklearn.linear_model import LinearRegression, Ridge
         from sklearn.svm import SVC
 
         return (
+            Ridge(),
             LinearRegression(),
             PCA(),
             DBSCAN(),
@@ -226,9 +227,12 @@ def test_preview_namespace():
 
         assert _is_preview_enabled()
 
-        lr, pca, dbscan, svc, rfc = get_estimators()
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
         assert "sklearnex" in rfc.__module__
 
+        if daal_check_version((2024, "P", 600)):
+            assert "sklearnex.preview" in ridge.__module__
+
         if daal_check_version((2023, "P", 100)):
             assert "sklearnex" in lr.__module__
         else:
@@ -242,7 +246,8 @@ def test_preview_namespace():
         sklearnex.unpatch_sklearn()
 
     # no patching behavior
-    lr, pca, dbscan, svc, rfc = get_estimators()
+    ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+    assert "sklearn." in ridge.__module__ and "daal4py" not in ridge.__module__
     assert "sklearn." in lr.__module__ and "daal4py" not in lr.__module__
     assert "sklearn." in pca.__module__ and "daal4py" not in pca.__module__
     assert "sklearn." in dbscan.__module__ and "daal4py" not in dbscan.__module__
@@ -254,7 +259,10 @@ def test_preview_namespace():
         sklearnex.patch_sklearn()
         assert not _is_preview_enabled()
 
-        lr, pca, dbscan, svc, rfc = get_estimators()
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+
+        assert "daal4py" in ridge.__module__
+
         if daal_check_version((2023, "P", 100)):
             assert "sklearnex" in lr.__module__
         else:

{scikit_learn_intelex-2024.5.0.data → scikit_learn_intelex-2024.7.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -43,6 +43,7 @@ from sklearnex.tests._utils import (
     SPECIAL_INSTANCES,
     UNPATCHED_FUNCTIONS,
     UNPATCHED_MODELS,
+    call_method,
     gen_dataset,
     gen_models_info,
 )
@@ -139,6 +140,9 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             ]:
                 pytest.skip(f"{estimator} does not support GPU queues")
 
+        if "NearestNeighbors" in estimator and "radius" in method:
+            pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+
         if estimator == "TSNE" and method == "fit_transform":
             pytest.skip("TSNE.fit_transform is too slow for common testing")
         elif (
@@ -148,30 +152,21 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             and dtype in [np.uint32, np.uint64]
         ):
             pytest.skip("Windows segmentation fault for Ridge.predict for unsigned ints")
-        elif estimator == "IncrementalLinearRegression" and dtype in [
-            np.int8,
-            np.int16,
-            np.int32,
-            np.int64,
-            np.uint8,
-            np.uint16,
-            np.uint32,
-            np.uint64,
-        ]:
+        elif estimator == "IncrementalLinearRegression" and np.issubdtype(
+            dtype, np.integer
+        ):
             pytest.skip(
                 "IncrementalLinearRegression fails on oneDAL side with int types because dataset is filled by zeroes"
             )
         elif method and not hasattr(est, method):
             pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
 
-        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)
+        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
         est.fit(X, y)
 
         if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+            call_method(est, method, X, y)
+
     assert all(
         [
             "running accelerated version" in i.message
@@ -190,23 +185,24 @@ def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator,
     with caplog.at_level(logging.WARNING, logger="sklearnex"):
         est = SPECIAL_INSTANCES[estimator]
 
-        # Its not possible to get the dpnp/dpctl arrays to be in the proper dtype
-        if dtype == np.float16 and queue and not queue.sycl_device.has_aspect_fp16:
-            pytest.skip("Hardware does not support fp16 SYCL testing")
-        elif dtype == np.float64 and queue and not queue.sycl_device.has_aspect_fp64:
-            pytest.skip("Hardware does not support fp64 SYCL testing")
+        if queue:
+            # Its not possible to get the dpnp/dpctl arrays to be in the proper dtype
+            if dtype == np.float16 and not queue.sycl_device.has_aspect_fp16:
+                pytest.skip("Hardware does not support fp16 SYCL testing")
+            elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
+                pytest.skip("Hardware does not support fp64 SYCL testing")
+
+        if "NearestNeighbors" in estimator and "radius" in method:
+            pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
-        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)
+        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
         est.fit(X, y)
 
         if method and not hasattr(est, method):
             pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
 
         if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+            call_method(est, method, X, y)
 
     assert all(
         [