scikit-learn-intelex 2025.8.0__py39-none-manylinux_2_28_x86_64.whl → 2025.9.0__py39-none-manylinux_2_28_x86_64.whl

daal4py/mb/__init__.py

@@ -53,15 +53,26 @@ def convert_model(model) -> "GBTDAALModel | LogisticDAALModel":
         offers faster prediction methods.
     """
     if isinstance(model, LogisticRegression):
+        # The multi_class keyword is removed in scikit-learn 1.8, and OvR functionality
+        # has been replaced by other estimators. Therefore checking for linear classifiers
+        # only dependent on the solver.
         if model.classes_.shape[0] > 2:
-            if (model.multi_class == "ovr") or (
-                model.multi_class == "auto" and model.solver == "liblinear"
-            ):
-                raise TypeError(
-                    "Supplied 'model' object is a linear classifier, but not multinomial logistic"
-                    " (hint: pass multi_class='multinomial' to 'LogisticRegression')."
-                )
-        elif (model.classes_.shape[0] == 2) and (model.multi_class == "multinomial"):
+            if not hasattr(model, "multi_class"):
+                if model.solver == "liblinear":
+                    raise TypeError(
+                        "Supplied 'model' object is a linear classifier, but not multinomial logistic"
+                    )
+            else:
+                if (model.multi_class == "ovr") or (
+                    model.multi_class == "auto" and model.solver == "liblinear"
+                ):
+                    raise TypeError(
+                        "Supplied 'model' object is a linear classifier, but not multinomial logistic"
+                        " (hint: pass multi_class='multinomial' to 'LogisticRegression')."
+                    )
+        elif (model.classes_.shape[0] == 2) and (
+            getattr(model, "multi_class", "auto") == "multinomial"
+        ):
             raise TypeError(
                 "Supplied 'model' object is not a logistic regressor "
                 "(hint: pass multi_class='auto' to 'LogisticRegression')."

daal4py/mb/logistic_regression_builders.py

@@ -97,21 +97,6 @@ class LogisticDAALModel:
         )
         builder.set_beta(coefs, intercepts)
         self._model = builder.model
-        self._alg_pred_class = logistic_regression_prediction(
-            nClasses=self.n_classes_,
-            fptype=self._fptype,
-            resultsToEvaluate="computeClassLabels",
-        )
-        self._alg_pred_prob = logistic_regression_prediction(
-            nClasses=self.n_classes_,
-            fptype=self._fptype,
-            resultsToEvaluate="computeClassProbabilities",
-        )
-        self._alg_pred_logprob = logistic_regression_prediction(
-            nClasses=self.n_classes_,
-            fptype=self._fptype,
-            resultsToEvaluate="computeClassLogProbabilities",
-        )
 
     @property
     def coef_(self):
@@ -121,6 +106,15 @@ class LogisticDAALModel:
     def intercept_(self):
         return self._model.Beta[:, 0]
 
+    def _logistic_regression_prediction(
+        self, X: np.ndarray, resultsToEvaluate: str
+    ) -> classifier_prediction_result:
+        return logistic_regression_prediction(
+            nClasses=self.n_classes_,
+            fptype=self._fptype,
+            resultsToEvaluate=resultsToEvaluate,
+        ).compute(X, self._model)
+
     def predict(self, X) -> np.ndarray:
         """
         Predict most probable class
@@ -133,7 +127,7 @@ class LogisticDAALModel:
             The most probable class, as integer indexes
         """
         return (
-            self._alg_pred_class.compute(X, self._model)
+            self._logistic_regression_prediction(X, "computeClassLabels")
             .prediction.reshape(-1)
             .astype(int)
         )
@@ -151,7 +145,9 @@ class LogisticDAALModel:
         proba : array(n_samples, n_classes)
             The predicted probabilities for each class.
         """
-        return self._alg_pred_prob.compute(X, self._model).probabilities
+        return self._logistic_regression_prediction(
+            X, "computeClassProbabilities"
+        ).probabilities
 
     predict_proba.__doc__ = predict_proba.__doc__.replace(r"%docstring_X%", _docstring_X)
 
@@ -166,7 +162,9 @@ class LogisticDAALModel:
         log_proba : array(n_samples, n_classes)
             The logarithms of the predicted probabilities for each class.
         """
-        return self._alg_pred_logprob.compute(X, self._model).logProbabilities
+        return self._logistic_regression_prediction(
+            X, "computeClassLogProbabilities"
+        ).logProbabilities
 
     predict_log_proba.__doc__ = predict_log_proba.__doc__.replace(
         r"%docstring_X%", _docstring_X
@@ -206,11 +204,7 @@ class LogisticDAALModel:
             raise ValueError(
                 "Must request at least one of 'classes', 'proba', 'log_proba'."
             )
-        return logistic_regression_prediction(
-            nClasses=self.n_classes_,
-            fptype=self._fptype,
-            resultsToEvaluate=pred_request,
-        ).compute(X, self._model)
+        return self._logistic_regression_prediction(X, pred_request)
 
     predict_multiple.__doc__ = predict_multiple.__doc__.replace(
         r"%docstring_X%", _docstring_X

daal4py/sklearn/linear_model/logistic_path.py

@@ -20,15 +20,14 @@ import numpy as np
 import scipy.optimize as optimize
 import scipy.sparse as sparse
 import sklearn.linear_model._logistic as logistic_module
-from sklearn.linear_model._sag import sag_solver
-from sklearn.utils import (
-    check_array,
-    check_consistent_length,
-    check_random_state,
-    compute_class_weight,
+from sklearn.linear_model._logistic import _LOGISTIC_SOLVER_CONVERGENCE_MSG
+from sklearn.linear_model._logistic import (
+    LogisticRegression as LogisticRegression_original,
 )
+from sklearn.linear_model._logistic import _check_solver
+from sklearn.utils import check_array, check_consistent_length, check_random_state
 from sklearn.utils.optimize import _check_optimize_result, _newton_cg
-from sklearn.utils.validation import _check_sample_weight, check_is_fitted
+from sklearn.utils.validation import check_is_fitted
 
 import daal4py as d4p
 
@@ -44,35 +43,6 @@ from .logistic_loss import (
     _daal4py_loss_and_grad,
 )
 
-if sklearn_check_version("1.1"):
-    from sklearn._loss.loss import HalfBinomialLoss, HalfMultinomialLoss
-    from sklearn.linear_model._linear_loss import LinearModelLoss
-    from sklearn.linear_model._logistic import _LOGISTIC_SOLVER_CONVERGENCE_MSG
-    from sklearn.linear_model._logistic import (
-        LogisticRegression as LogisticRegression_original,
-    )
-    from sklearn.linear_model._logistic import (
-        _check_multi_class,
-        _check_solver,
-        _fit_liblinear,
-    )
-else:
-    from sklearn.linear_model._logistic import _LOGISTIC_SOLVER_CONVERGENCE_MSG
-    from sklearn.linear_model._logistic import (
-        LogisticRegression as LogisticRegression_original,
-    )
-    from sklearn.linear_model._logistic import (
-        _check_multi_class,
-        _check_solver,
-        _fit_liblinear,
-        _logistic_grad_hess,
-        _logistic_loss,
-        _logistic_loss_and_grad,
-        _multinomial_grad_hess,
-        _multinomial_loss,
-        _multinomial_loss_grad,
-    )
-
 if sklearn_check_version("1.7.1"):
     from sklearn.utils.fixes import _get_additional_lbfgs_options_dict
 else:
@@ -86,6 +56,25 @@ from sklearn.linear_model._logistic import _logistic_regression_path as lr_path_
 from sklearn.preprocessing import LabelBinarizer, LabelEncoder
 
 
+# This code is a patch for sklearn 1.8, which is related to https://github.com/scikit-learn/scikit-learn/pull/32073
+# where the multi_class keyword is deprecated and this aspect is removed.
+def _check_multi_class(multi_class, solver, n_classes):
+    """Computes the multi class type, either "multinomial" or "ovr".
+    For `n_classes` > 2 and a solver that supports it, returns "multinomial".
+    For all other cases, in particular binary classification, return "ovr".
+    """
+    if multi_class == "auto":
+        if solver in ("liblinear",):
+            multi_class = "ovr"
+        elif n_classes > 2:
+            multi_class = "multinomial"
+        else:
+            multi_class = "ovr"
+    if multi_class == "multinomial" and solver in ("liblinear",):
+        raise ValueError("Solver %s does not support a multinomial backend." % solver)
+    return multi_class
+
+
 # Code adapted from sklearn.linear_model.logistic version 0.21
 def __logistic_regression_path(
     X,
@@ -110,46 +99,6 @@ def __logistic_regression_path(
     l1_ratio=None,
     n_threads=1,
 ):
-    _patching_status = PatchingConditionsChain(
-        "sklearn.linear_model.LogisticRegression.fit"
-    )
-    _dal_ready = _patching_status.and_conditions(
-        [
-            (
-                solver in ["lbfgs", "newton-cg"],
-                f"'{solver}' solver is not supported. "
-                "Only 'lbfgs' and 'newton-cg' solvers are supported.",
-            ),
-            (not sparse.issparse(X), "X is sparse. Sparse input is not supported."),
-            (sample_weight is None, "Sample weights are not supported."),
-            (class_weight is None, "Class weights are not supported."),
-        ]
-    )
-    if not _dal_ready:
-        _patching_status.write_log()
-        return lr_path_original(
-            X,
-            y,
-            pos_class=pos_class,
-            Cs=Cs,
-            fit_intercept=fit_intercept,
-            max_iter=max_iter,
-            tol=tol,
-            verbose=verbose,
-            solver=solver,
-            coef=coef,
-            class_weight=class_weight,
-            dual=dual,
-            penalty=penalty,
-            intercept_scaling=intercept_scaling,
-            multi_class=multi_class,
-            random_state=random_state,
-            check_input=check_input,
-            max_squared_sum=max_squared_sum,
-            sample_weight=sample_weight,
-            l1_ratio=l1_ratio,
-            **({"n_threads": n_threads} if sklearn_check_version("1.1") else {}),
-        )
 
     # Comment 2025-08-04: this file might have dead code paths from unsupported solvers.
     # It appears to have initially been a copy-paste of scikit-learn with a few additions
@@ -269,7 +218,6 @@ def __logistic_regression_path(
             func = _daal4py_loss_
             grad = _daal4py_grad_
             hess = _daal4py_grad_hess_
-        warm_start_sag = {"coef": w0.T}
     else:
         target = y_bin
         if solver == "lbfgs":
@@ -280,7 +228,6 @@ def __logistic_regression_path(
             func = _daal4py_loss_
             grad = _daal4py_grad_
             hess = _daal4py_grad_hess_
-        warm_start_sag = {"coef": np.expand_dims(w0, axis=1)}
 
     coefs = list()
     n_iter = np.zeros(len(Cs), dtype=np.int32)
@@ -385,8 +332,6 @@ def __logistic_regression_path(
         for i, ci in enumerate(coefs):
             coefs[i] = np.delete(ci, 0, axis=-1)
 
-    _patching_status.write_log()
-
     return np.array(coefs), np.array(Cs), n_iter
 
 
@@ -427,12 +372,13 @@ def daal4py_predict(self, X, resultsToEvaluate):
         f"sklearn.linear_model.LogisticRegression.{_function_name}"
     )
     if _function_name != "predict":
+        multi_class = getattr(self, "multi_class", "auto")
         _patching_status.and_conditions(
             [
                 (
                     self.classes_.size == 2
-                    or logistic_module._check_multi_class(
-                        self.multi_class if self.multi_class != "deprecated" else "auto",
+                    or _check_multi_class(
+                        multi_class if multi_class != "deprecated" else "auto",
                         self.solver,
                         self.classes_.size,
                     )
@@ -440,7 +386,7 @@ def daal4py_predict(self, X, resultsToEvaluate):
                     f"selected multiclass option is not supported for n_classes > 2.",
                 ),
                 (
-                    not (self.classes_.size == 2 and self.multi_class == "multinomial"),
+                    not (self.classes_.size == 2 and multi_class == "multinomial"),
                     "multi_class='multinomial' not supported with binary data",
                 ),
             ],
@@ -502,52 +448,35 @@ def daal4py_predict(self, X, resultsToEvaluate):
         return LogisticRegression_original.predict_log_proba(self, X)
 
 
-def logistic_regression_path(
-    X,
-    y,
-    pos_class=None,
-    Cs=10,
-    fit_intercept=True,
-    max_iter=100,
-    tol=1e-4,
-    verbose=0,
-    solver="lbfgs",
-    coef=None,
-    class_weight=None,
-    dual=False,
-    penalty="l2",
-    intercept_scaling=1.0,
-    multi_class="auto",
-    random_state=None,
-    check_input=True,
-    max_squared_sum=None,
-    sample_weight=None,
-    l1_ratio=None,
-    n_threads=1,
-):
-    return __logistic_regression_path(
-        X,
-        y,
-        pos_class=pos_class,
-        Cs=Cs,
-        fit_intercept=fit_intercept,
-        max_iter=max_iter,
-        tol=tol,
-        verbose=verbose,
-        solver=solver,
-        coef=coef,
-        class_weight=class_weight,
-        dual=dual,
-        penalty=penalty,
-        intercept_scaling=intercept_scaling,
-        multi_class=multi_class,
-        random_state=random_state,
-        check_input=check_input,
-        max_squared_sum=max_squared_sum,
-        sample_weight=sample_weight,
-        l1_ratio=l1_ratio,
-        n_threads=n_threads,
+def logistic_regression_path(*args, **kwargs):
+
+    _patching_status = PatchingConditionsChain(
+        "sklearn.linear_model.LogisticRegression.fit"
+    )
+    _dal_ready = _patching_status.and_conditions(
+        [
+            (
+                kwargs["solver"] in ["lbfgs", "newton-cg"],
+                f"'{kwargs['solver']}' solver is not supported. "
+                "Only 'lbfgs' and 'newton-cg' solvers are supported.",
+            ),
+            (not sparse.issparse(args[0]), "X is sparse. Sparse input is not supported."),
+            (kwargs["sample_weight"] is None, "Sample weights are not supported."),
+            (kwargs["class_weight"] is None, "Class weights are not supported."),
+        ]
     )
+    if not _dal_ready:
+        _patching_status.write_log()
+        return lr_path_original(*args, **kwargs)
+
+    if sklearn_check_version("1.8"):
+        kwargs.pop("classes", None)
+        res = __logistic_regression_path(*(args[:2]), **kwargs)
+    else:
+        res = __logistic_regression_path(*args, **kwargs)
+
+    _patching_status.write_log()
+    return res
 
 
 @control_n_jobs(

daal4py/sklearn/monkeypatch/tests/_models_info.py

@@ -30,7 +30,7 @@ from sklearn.manifold import TSNE
 from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors
 from sklearn.svm import SVC
 
-from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
 MODELS_INFO = [
     {
@@ -84,7 +84,10 @@ MODELS_INFO = [
         "dataset": "classifier",
     },
     {
-        "model": LogisticRegression(max_iter=100, multi_class="multinomial"),
+        "model": LogisticRegression(
+            max_iter=100,
+            **({} if sklearn_check_version("1.8") else {"multi_class": "multinomial"})
+        ),
         "methods": [
             "decision_function",
             "predict",

daal4py/sklearn/utils/validation.py

@@ -280,9 +280,9 @@ def _daal_check_array(
     array_converted : object
         The converted and validated array.
     """
-    if force_all_finite not in (True, False, "allow-nan"):
+    if force_all_finite not in (True, False, "allow-nan", None):
         raise ValueError(
-            'force_all_finite should be a bool or "allow-nan"'
+            'force_all_finite should be a bool, None, or "allow-nan"'
             ". Got {!r} instead".format(force_all_finite)
         )
 

onedal/covariance/covariance.py

@@ -20,7 +20,6 @@ import numpy as np
 from daal4py.sklearn._utils import daal_check_version
 from onedal._device_offload import supports_queue
 from onedal.common._backend import bind_default_backend
-from onedal.utils.validation import _check_array
 
 from .._config import _get_config
 from ..common.hyperparameters import get_hyperparameters
@@ -101,13 +100,7 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        use_raw_input = _get_config()["use_raw_input"] is True
-        sua_iface, xp, _ = _get_sycl_namespace(X)
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
 
-        if not use_raw_input:
-            X = _check_array(X, dtype=[np.float64, np.float32])
         X_table = to_table(X, queue=queue)
 
         params = self._get_onedal_params(X_table.dtype)
@@ -123,6 +116,6 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
                 from_table(result.cov_matrix, like=X) * (X.shape[0] - 1) / X.shape[0]
             )
 
-        self.location_ = xp.squeeze(from_table(result.means, like=X))
+        self.location_ = from_table(result.means, like=X)[0, ...]
 
         return self

onedal/covariance/incremental_covariance.py

@@ -17,12 +17,12 @@
 import numpy as np
 
 from daal4py.sklearn._utils import daal_check_version
-from onedal._device_offload import supports_queue
-from onedal.common._backend import bind_default_backend
-from onedal.utils import _sycl_queue_manager as QM
 
 from .._config import _get_config
-from ..datatypes import from_table, to_table
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
 from ..utils._array_api import _get_sycl_namespace
 from ..utils.validation import _check_array
 from .covariance import BaseEmpiricalCovariance
@@ -74,6 +74,7 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
     def _reset(self):
         self._need_to_finalize = False
         self._queue = None
+        self._outtype = None
         self._partial_result = self.partial_compute_result()
 
     def __getstate__(self):
@@ -108,15 +109,10 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        use_raw_input = _get_config()["use_raw_input"] is True
-        sua_iface, _, _ = _get_sycl_namespace(X)
-
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
-        if not use_raw_input:
-            X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
 
         self._queue = queue
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
@@ -125,8 +121,6 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         params = self._get_onedal_params(self._dtype)
         self._partial_result = self.partial_compute(params, self._partial_result, X_table)
         self._need_to_finalize = True
-        # store the queue for when we finalize
-        self._queue = queue
 
     def finalize_fit(self):
         """Finalize covariance matrix from the current `_partial_result`.
@@ -143,13 +137,14 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
             with QM.manage_global_queue(self._queue):
                 result = self.finalize_compute(params, self._partial_result)
 
-            if daal_check_version((2024, "P", 1)) or (not self.bias):
-                self.covariance_ = from_table(result.cov_matrix)
-            else:
+            self.covariance_ = from_table(result.cov_matrix, like=self._outtype)
+
+            if self.bias and not daal_check_version((2024, "P", 1)):
                 n_rows = self._partial_result.partial_n_rows
-                self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
+                self.covariance_ *= (n_rows - 1) / n_rows
 
-            self.location_ = from_table(result.means).ravel()
+            self.location_ = from_table(result.means, like=self._outtype)[0, ...]
+            self._outtype = None
 
             self._need_to_finalize = False
 

onedal/covariance/tests/test_covariance.py

@@ -25,7 +25,7 @@ from onedal.tests.utils._device_selection import get_queues
 def test_onedal_import_covariance(queue):
     from onedal.covariance import EmpiricalCovariance
 
-    X = np.array([[0, 1], [0, 1]])
+    X = np.array([[0, 1], [0, 1]], dtype=np.float64)
     result = EmpiricalCovariance().fit(X, queue=queue)
     expected_covariance = np.array([[0, 0], [0, 0]])
     expected_means = np.array([0, 1])
@@ -33,7 +33,7 @@ def test_onedal_import_covariance(queue):
     assert_allclose(expected_covariance, result.covariance_)
     assert_allclose(expected_means, result.location_)
 
-    X = np.array([[1, 2], [3, 6]])
+    X = np.array([[1, 2], [3, 6]], dtype=np.float64)
     result = EmpiricalCovariance().fit(X, queue=queue)
     expected_covariance = np.array([[2, 4], [4, 8]])
     expected_means = np.array([2, 4])
@@ -41,7 +41,7 @@ def test_onedal_import_covariance(queue):
     assert_allclose(expected_covariance, result.covariance_)
     assert_allclose(expected_means, result.location_)
 
-    X = np.array([[1, 2], [3, 6]])
+    X = np.array([[1, 2], [3, 6]], dtype=np.float64)
     result = EmpiricalCovariance(bias=True).fit(X, queue=queue)
     expected_covariance = np.array([[1, 2], [2, 4]])
     expected_means = np.array([2, 4])

onedal/datatypes/_data_conversion.py

@@ -112,7 +112,9 @@ def return_type_constructor(array):
             )
 
     elif hasattr(array, "__array_namespace__"):
-        func = array.__array_namespace__().from_dlpack
+        xp = array.__array_namespace__()
+        device = array.device
+        func = lambda inp: xp.from_dlpack(inp, device=device)
     else:
         try:
             func = _compat_convert(array)

onedal/datatypes/_dlpack.py

@@ -45,11 +45,14 @@ def dlpack_to_numpy(obj):
             raise TypeError(f"cannot move {type(obj)} to cpu")
 
     # convert to numpy
-    if hasattr(obj, "__array__"):
-        # ``copy`` param for the ``asarray`` is not set.
-        # The object is copied only if needed
-        obj = np.asarray(obj)
-    else:
+    try:
+        # Some frameworks implement an __array__ method just to
+        # throw a RuntimeError when used (array_api_strict, dpctl),
+        # or a TypeError (array_api-strict) rather than an AttributeError
+        # therefore a try catch is necessary (logic is essentially a
+        # getattr call + some)
+        obj = obj.__array__()
+    except (AttributeError, RuntimeError, TypeError):
         # requires numpy 1.23
         try:
             obj = np.from_dlpack(obj)

onedal/datatypes/tests/test_data.py

@@ -578,7 +578,7 @@ def test_table_conversions_dlpack(dataframe, queue, order, data_shape, dtype):
 
 
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy,array_api", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
@@ -616,3 +616,71 @@ def test_table___dlpack__(dataframe, queue, order, data_shape, dtype):
     del capsule
     gc.collect()
     assert_allclose(np.squeeze(from_table(X_table)), np.squeeze(X))
+
+
+@pytest.mark.skipif(
+    not hasattr(np, "from_dlpack"), reason="no dlpack support in installed numpy"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("dpctl", "cpu,gpu"))
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
+def test_table_convert_to_host_dlpack(dataframe, queue, order, data_shape, dtype):
+    """Test if __dlpack__ attribute can be properly consumed by moving data
+    to host from a SYCL device.
+    """
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample(data_shape), dtype=dtype)
+
+    X = ORDER_DICT[order](X)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    X_table = to_table(X_df)
+    # verify that it is on a kDLOneAPI device
+    assert X_df.__dlpack_device__() == X_table.__dlpack_device__()
+
+    # extract to numpy (which should move to host)
+    try:
+        X_out = np.from_dlpack(X_table)
+    except RuntimeError as e:
+        if "Unsupported device in DLTensor." in str(e):
+            pytest.skip("Numpy version cannot request device conversion")
+        else:
+            raise e
+    assert X_out.__dlpack_device__() != X_table.__dlpack_device__()
+
+    if X_out.dtype == X.dtype:
+        assert_array_equal(np.squeeze(X_out), np.squeeze(X))
+    else:
+        assert_allclose(np.squeeze(X_out), np.squeeze(X))
+
+    # verify that table immutability is gone and copy behavior has been followed
+    assert X_out.flags.writeable
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_table_writable_dlpack(queue):
+    """Test if __dlpack__ attribute can be properly consumed by moving data
+    to host from a SYCL device.
+    """
+    xp = pytest.importorskip("dpctl.tensor")
+    X = xp.eye(5, 8, dtype=xp.float32, device=queue)
+    X.flags["W"] = False
+    X_table = to_table(X)
+
+    cpu_device = (backend.kDLCPU, 0)
+    # verify that it is on a kDLOneAPI device
+    assert X.__dlpack_device__() == X_table.__dlpack_device__()
+    assert X_table.__dlpack_device__() != cpu_device
+
+    # verify move to host
+    X_table.__dlpack__(dl_device=cpu_device)
+    # verify error is raised when copy=False
+    with pytest.raises(BufferError, match="Cannot transfer data to requested device"):
+        X_table.__dlpack__(dl_device=cpu_device, copy=False)
+
+    for copy_bool in [True, False]:
+        X_out = xp.from_dlpack(X_table, copy=copy_bool)
+        # verify that table immutability is gone and copy behavior has been followed
+        assert X_out.flags["W"] is copy_bool