scikit-learn-intelex 2025.5.0__py311-none-manylinux_2_28_x86_64.whl → 2025.6.1__py311-none-manylinux_2_28_x86_64.whl

daal4py/mb/gbt_convertors.py

@@ -19,7 +19,6 @@ from collections import deque
 from copy import deepcopy
 from tempfile import NamedTemporaryFile
 from typing import Any, Deque, Dict, List, Optional, Tuple
-from warnings import warn
 
 import numpy as np
 
@@ -94,18 +93,9 @@ class CatBoostModelData:
         else:
             return len(self.trees)
 
-    @property
-    def bias(self):
-        if self.is_classification:
-            return 0
-        return self.__data["scale_and_bias"][1][0] / self.n_iterations
-
     @property
     def scale(self):
-        if self.is_classification:
-            return 1
-        else:
-            return self.__data["scale_and_bias"][0]
+        return self.__data["scale_and_bias"][0]
 
     @property
     def default_left(self):
@@ -223,7 +213,7 @@ class Node:
             return self.__feature
         if isinstance(self.__feature, str) and self.__feature.isnumeric():
             return int(self.__feature)
-        raise ValueError(
+        raise AttributeError(
             f"Feature names must be integers (got ({type(self.__feature)}){self.__feature})"
         )
 
@@ -242,15 +232,15 @@ class TreeView:
     @property
     def value(self) -> float:
         if not self.is_leaf:
-            raise ValueError("Tree is not a leaf-only tree")
+            raise AttributeError("Tree is not a leaf-only tree")
         if self.root_node.value is None:
-            raise ValueError("Tree is leaf-only but leaf node has no value")
+            raise AttributeError("Tree is leaf-only but leaf node has no value")
         return self.root_node.value
 
     @property
     def cover(self) -> float:
         if not self.is_leaf:
-            raise ValueError("Tree is not a leaf-only tree")
+            raise AttributeError("Tree is not a leaf-only tree")
         return self.root_node.cover
 
     @property
@@ -427,6 +417,18 @@ def get_gbt_model_from_tree_list(
 
 
 def get_gbt_model_from_lightgbm(model: Any, booster=None) -> Any:
+    model_str = model.model_to_string()
+    if "is_linear=1" in model_str:
+        raise TypeError("Linear trees are not supported.")
+    if "[boosting: dart]" in model_str:
+        raise TypeError("'Dart' booster is not supported.")
+    if "[boosting: rf]" in model_str:
+        raise TypeError("Random forest boosters are not supported.")
+    if ("[objective: lambdarank]" in model_str) or (
+        "[objective: rank_xendcg]" in model_str
+    ):
+        raise TypeError("Ranking objectives are not supported.")
+
     if booster is None:
         booster = model.dump_model()
 
@@ -437,9 +439,9 @@ def get_gbt_model_from_lightgbm(model: Any, booster=None) -> Any:
     is_regression = False
     objective_fun = booster["objective"]
     if n_classes > 2:
-        if "multiclass" not in objective_fun:
+        if ("ova" in objective_fun) or ("ovr" in objective_fun):
             raise TypeError(
-                "multiclass (softmax) objective is only supported for multiclass classification"
+                "Only multiclass (softmax) objective is supported for multiclass classification"
             )
     elif "binary" in objective_fun:  # nClasses == 1
         n_classes = 2
@@ -473,6 +475,13 @@ def get_gbt_model_from_xgboost(booster: Any, xgb_config=None) -> Any:
     if xgb_config is None:
         xgb_config = get_xgboost_params(booster)
 
+    if xgb_config["learner"]["learner_train_param"]["booster"] != "gbtree":
+        raise TypeError("Only 'gbtree' booster type is supported.")
+
+    n_targets = xgb_config["learner"]["learner_model_param"].get("num_target")
+    if n_targets is not None and int(n_targets) > 1:
+        raise TypeError("Multi-target boosters are not supported.")
+
     n_features = int(xgb_config["learner"]["learner_model_param"]["num_feature"])
     n_classes = int(xgb_config["learner"]["learner_model_param"]["num_class"])
     base_score = float(xgb_config["learner"]["learner_model_param"]["base_score"])
@@ -504,11 +513,6 @@ def get_gbt_model_from_xgboost(booster: Any, xgb_config=None) -> Any:
         if objective_fun == "binary:logitraw":
             # daal4py always applies a sigmoid for pred_proba, wheres XGBoost
             # returns raw predictions with logitraw
-            warn(
-                "objective='binary:logitraw' selected\n"
-                "XGBoost returns raw class scores when calling pred_proba()\n"
-                "whilst scikit-learn-intelex always uses binary:logistic\n"
-            )
             base_score = float(1 / (1 + np.exp(-base_score)))
     else:
         is_regression = True
@@ -567,6 +571,22 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
             "Categorical features are not supported in daal4py Gradient Boosting Trees"
         )
 
+    objective = booster.get_params().get("objective", "")
+    if (
+        "Rank" in objective
+        or "Query" in objective
+        or "Pair" in objective
+        or objective in ["LambdaMart", "StochasticFilter", "GroupQuantile"]
+    ):
+        raise TypeError("Ranking objectives are not supported.")
+    if "Multi" in objective and objective != "MultiClass":
+        if model.is_classification:
+            raise TypeError(
+                "Only 'MultiClass' loss is supported for multi-class classification."
+            )
+        else:
+            raise TypeError("Multi-output models are not supported.")
+
     if model.is_classification:
         mb = gbt_clf_model_builder(
             n_features=model.n_features,
@@ -587,21 +607,37 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                     {"feature_index": feature["feature_index"], "value": feature_border}
                 )
 
+    # Note: catboost models might have a 'bias' (intercept) which gets added
+    # to all predictions. In the case of single-output models, this is a scalar,
+    # but in the case of multi-output models such as multinomial logistic, it
+    # is a vector. Since daal4py doesn't support vector-valued intercepts, this
+    # adds the intercept to every terminal node instead, by dividing it equally
+    # among all trees. Usually, catboost would anyway set them to zero, but it
+    # still allows setting custom intercepts.
+    cb_bias = booster.get_scale_and_bias()[1]
+    add_intercept_to_each_node = isinstance(cb_bias, list)
+    if add_intercept_to_each_node:
+        cb_bias = np.array(cb_bias) / model.n_iterations
+        if not model.is_classification:
+            raise TypeError("Multi-output regression models are not supported.")
+
+    def add_vector_bias(values: list[float]) -> list[float]:
+        return list(np.array(values) + cb_bias)
+
     trees_explicit = []
     tree_symmetric = []
 
+    all_trees_are_empty = True
+
     if model.is_symmetric_tree:
         for tree in model.oblivious_trees:
-            cur_tree_depth = len(tree.get("splits", []))
+            tree_splits = tree.get("splits", [])
+            cur_tree_depth = len(tree_splits) if tree_splits is not None else 0
             tree_symmetric.append((tree, cur_tree_depth))
     else:
         for tree in model.trees:
             n_nodes = 1
-            if "split" not in tree:
-                # handle leaf node
-                values = __get_value_as_list(tree)
-                root_node = CatBoostNode(value=[value * model.scale for value in values])
-                continue
+
             # Check if node is a leaf (in case of stump)
             if "split" in tree:
                 # Get number of trees and splits info via BFS
@@ -622,12 +658,15 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                         nodes_queue.append((cur_node_data["left"], left_node))
                         nodes_queue.append((cur_node_data["right"], right_node))
                         n_nodes += 2
+                        all_trees_are_empty = False
             else:
                 root_node = CatBoostNode()
                 if model.is_classification and model.n_classes > 2:
                     root_node.value = [value * model.scale for value in tree["value"]]
+                    if add_intercept_to_each_node:
+                        root_node.value = add_vector_bias(root_node.value)
                 else:
-                    root_node.value = [tree["value"] * model.scale + model.bias]
+                    root_node.value = [tree["value"] * model.scale]
             trees_explicit.append((root_node, n_nodes))
 
     tree_id = []
@@ -646,9 +685,15 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
     for i in range(model.n_iterations):
         for _ in range(n_tree_each_iter):
             if model.is_symmetric_tree:
-                n_nodes = 2 ** (tree_symmetric[i][1] + 1) - 1
+                if not len(tree_symmetric):
+                    n_nodes = 1
+                else:
+                    n_nodes = 2 ** (tree_symmetric[i][1] + 1) - 1
             else:
-                n_nodes = trees_explicit[i][1]
+                if not len(trees_explicit):
+                    n_nodes = 1
+                else:
+                    n_nodes = trees_explicit[i][1]
 
             if model.is_classification and model.n_classes > 2:
                 tree_id.append(mb.create_tree(n_nodes, class_label))
@@ -663,9 +708,9 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                 tree_id.append(mb.create_tree(n_nodes))
 
     if model.is_symmetric_tree:
+        shap_ready = True  # this code branch provides all info for SHAP values
         for class_label in range(n_tree_each_iter):
             for i in range(model.n_iterations):
-                shap_ready = True  # this code branch provides all info for SHAP values
                 cur_tree_info = tree_symmetric[i][0]
                 cur_tree_id = tree_id[i * n_tree_each_iter + class_label]
                 cur_tree_leaf_val = cur_tree_info["leaf_values"]
@@ -674,7 +719,8 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                 if cur_tree_depth == 0:
                     mb.add_leaf(
                         tree_id=cur_tree_id,
-                        response=cur_tree_leaf_val[0],
+                        response=cur_tree_leaf_val[class_label] * model.scale
+                        + (cb_bias[class_label] if add_intercept_to_each_node else 0),
                         cover=cur_tree_leaf_weights[0],
                     )
                 else:
@@ -686,6 +732,7 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                         cur_tree_leaf_weights
                     )
                     root_weight = cur_tree_weights_per_level[0][0]
+
                     root_id = mb.add_split(
                         tree_id=cur_tree_id,
                         feature_index=cur_level_split["feature_index"],
@@ -704,6 +751,9 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                             cur_level_split = splits[
                                 cur_tree_info["splits"][cur_level]["split_index"]
                             ]
+                            cover_nodes = next_level_weights[cur_level_node_index]
+                            if cover_nodes == 0:
+                                shap_ready = False
                             cur_left_node = mb.add_split(
                                 tree_id=cur_tree_id,
                                 parent_id=cur_parent,
@@ -711,7 +761,7 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                                 feature_index=cur_level_split["feature_index"],
                                 feature_value=cur_level_split["value"],
                                 default_left=model.default_left,
-                                cover=next_level_weights[cur_level_node_index],
+                                cover=cover_nodes,
                             )
                             # cur_level_node_index += 1
                             cur_right_node = mb.add_split(
@@ -721,7 +771,7 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                                 feature_index=cur_level_split["feature_index"],
                                 feature_value=cur_level_split["value"],
                                 default_left=model.default_left,
-                                cover=next_level_weights[cur_level_node_index],
+                                cover=cover_nodes,
                             )
                             # cur_level_node_index += 1
                             cur_level_nodes.append(cur_left_node)
@@ -734,8 +784,7 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
                                 response=cur_tree_leaf_val[2 * last_level_node_num]
-                                * model.scale
-                                + model.bias,
+                                * model.scale,
                                 parent_id=prev_level_nodes[last_level_node_num],
                                 position=0,
                                 cover=cur_tree_leaf_weights[2 * last_level_node_num],
@@ -743,8 +792,7 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
                                 response=cur_tree_leaf_val[2 * last_level_node_num + 1]
-                                * model.scale
-                                + model.bias,
+                                * model.scale,
                                 parent_id=prev_level_nodes[last_level_node_num],
                                 position=1,
                                 cover=cur_tree_leaf_weights[2 * last_level_node_num + 1],
@@ -761,7 +809,11 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
                                 response=cur_tree_leaf_val[left_index] * model.scale
-                                + model.bias,
+                                + (
+                                    cb_bias[class_label]
+                                    if add_intercept_to_each_node
+                                    else 0
+                                ),
                                 parent_id=prev_level_nodes[last_level_node_num],
                                 position=0,
                                 cover=0.0,
@@ -769,13 +821,18 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
                                 response=cur_tree_leaf_val[right_index] * model.scale
-                                + model.bias,
+                                + (
+                                    cb_bias[class_label]
+                                    if add_intercept_to_each_node
+                                    else 0
+                                ),
                                 parent_id=prev_level_nodes[last_level_node_num],
                                 position=1,
                                 cover=0.0,
                             )
     else:
         shap_ready = False
+        scale = booster.get_scale_and_bias()[0]
         for class_label in range(n_tree_each_iter):
             for i in range(model.n_iterations):
                 root_node = trees_explicit[i][0]
@@ -809,7 +866,12 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                         else:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
-                                response=left_node.value[class_label],
+                                response=scale * left_node.value[class_label]
+                                + (
+                                    cb_bias[class_label]
+                                    if add_intercept_to_each_node
+                                    else 0
+                                ),
                                 parent_id=cur_node_id,
                                 position=0,
                                 cover=0.0,
@@ -830,7 +892,12 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
                         else:
                             mb.add_leaf(
                                 tree_id=cur_tree_id,
-                                response=cur_node.right.value[class_label],
+                                response=scale * cur_node.right.value[class_label]
+                                + (
+                                    cb_bias[class_label]
+                                    if add_intercept_to_each_node
+                                    else 0
+                                ),
                                 parent_id=cur_node_id,
                                 position=1,
                                 cover=0.0,
@@ -838,18 +905,18 @@ def get_gbt_model_from_catboost(booster: Any) -> Any:
 
                 else:
                     # Tree has only one node
+                    # Note: the root node already has scale and bias added to it,
+                    # so no need to add them again here like it is done for the leafs.
                     mb.add_leaf(
                         tree_id=cur_tree_id,
                         response=root_node.value[class_label],
                         cover=0.0,
                     )
 
-    if not shap_ready:
-        warn("Converted models of this type do not support SHAP value calculation")
-    else:
-        warn(
-            "CatBoost SHAP values seem to be incorrect. "
-            "Values from converted models will differ. "
-            "See https://github.com/catboost/catboost/issues/2556 for more details."
-        )
-    return mb.model(base_score=0.0)
+    if all_trees_are_empty and not model.is_symmetric_tree:
+        shap_ready = True
+
+    intercept = 0.0
+    if not add_intercept_to_each_node:
+        intercept = booster.get_scale_and_bias()[1]
+    return mb.model(base_score=intercept), shap_ready

daal4py/mb/tree_based_builders.py

@@ -16,6 +16,7 @@
 
 # daal4py Model builders API
 
+import warnings
 from typing import Literal, Optional
 
 import numpy as np
@@ -91,21 +92,25 @@ class GBTDAALBaseModel:
     def _get_params_from_catboost(self, params):
         if "class_params" in params["model_info"]:
             self.n_classes_ = len(params["model_info"]["class_params"]["class_to_label"])
+        else:
+            self.n_classes_ = 1
         self.n_features_in_ = len(params["features_info"]["float_features"])
 
     def _convert_model_from_lightgbm(self, booster):
         lgbm_params = get_lightgbm_params(booster)
         self.daal_model_ = get_gbt_model_from_lightgbm(booster, lgbm_params)
         self._get_params_from_lightgbm(lgbm_params)
+        self.supports_shap_ = self.n_classes_ < 3
 
     def _convert_model_from_xgboost(self, booster):
         xgb_params = get_xgboost_params(booster)
         self.daal_model_ = get_gbt_model_from_xgboost(booster, xgb_params)
         self._get_params_from_xgboost(xgb_params)
+        self.supports_shap_ = self.n_classes_ < 3
 
     def _convert_model_from_catboost(self, booster):
         catboost_params = get_catboost_params(booster)
-        self.daal_model_ = get_gbt_model_from_catboost(booster)
+        self.daal_model_, self.supports_shap_ = get_gbt_model_from_catboost(booster)
         self._get_params_from_catboost(catboost_params)
 
     def _convert_model(self, model):
@@ -249,21 +254,17 @@ class GBTDAALBaseModel:
                 X, fptype, pred_contribs, pred_interactions
             )
         except TypeError as e:
-            if "unexpected keyword argument 'resultsToCompute'" in str(e):
-                if pred_contribs or pred_interactions:
-                    # SHAP values requested, but not supported by this version
-                    raise TypeError(
-                        f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daalp4y"
-                    ) from e
+            if "unexpected keyword argument 'resultsToCompute'" in str(e) and (
+                pred_contribs or pred_interactions
+            ):
+                # SHAP values requested, but not supported by this version
+                raise TypeError(
+                    f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daalp4y"
+                ) from e
             else:
                 # unknown type error
                 raise
 
-        # fallback to calculation without `resultsToCompute`
-        predict_algo = d4p.gbt_regression_prediction(fptype=fptype)
-        predict_result = predict_algo.compute(X, self.daal_model_)
-        return predict_result.prediction.ravel()
-
     def _predict_regression_with_results_to_compute(
         self, X, fptype, pred_contribs=False, pred_interactions=False
     ):
@@ -316,6 +317,15 @@ class GBTDAALModel(GBTDAALBaseModel):
     model : booster object from another library
         The fitted GBT model from which this object will be created. See rest of the documentation
         for supported input types.
+
+    Attributes
+    ----------
+    is_classifier_ : bool
+        Whether this is a classification model.
+    is_regressor_ : bool
+        Whether this is a regression model.
+    supports_shap_ : bool
+        Whether the model supports SHAP calculations.
     """
 
     def __init__(self, model):
@@ -345,14 +355,19 @@ class GBTDAALModel(GBTDAALBaseModel):
 
         :rtype: np.ndarray
         """
+        if pred_contribs or pred_interactions:
+            if not self.supports_shap_:
+                raise TypeError("SHAP calculations are not available for this model.")
+            if self.model_type == "catboost":
+                warnings.warn(
+                    "SHAP values from models converted from CatBoost do not match "
+                    "against those of the original library. See "
+                    "https://github.com/catboost/catboost/issues/2556 for more details."
+                )
         fptype = getFPType(X)
         if self._is_regression:
             return self._predict_regression(X, fptype, pred_contribs, pred_interactions)
         else:
-            if (pred_contribs or pred_interactions) and self.model_type != "xgboost":
-                raise NotImplementedError(
-                    f"{'pred_contribs' if pred_contribs else 'pred_interactions'} is not implemented for classification models"
-                )
             return self._predict_classification(
                 X, fptype, "computeClassLabels", pred_contribs, pred_interactions
             )

daal4py/sklearn/ensemble/_forest.py

@@ -679,8 +679,8 @@ class RandomForestClassifier(RandomForestClassifier_original, RandomForestBase):
         dfc_predictionResult = dfc_algorithm.compute(X, self.daal_model_)
 
         pred = dfc_predictionResult.probabilities
-
-        return pred
+        # TODO: fix probabilities out of [0, 1] interval on oneDAL side
+        return pred.clip(0.0, 1.0)
 
     def _daal_fit_classifier(self, X, y, sample_weight=None):
         y = check_array(y, ensure_2d=False, dtype=None)

daal4py/sklearn/manifold/_t_sne.py

@@ -66,7 +66,13 @@ class TSNE(BaseTSNE):
             [n_samples],
             [P.nnz],
             [self.n_iter_without_progress],
-            [self._max_iter if sklearn_check_version("1.5") else self.n_iter],
+            [
+                (
+                    self.max_iter
+                    if sklearn_check_version("1.7")
+                    else (self._max_iter if sklearn_check_version("1.5") else self.n_iter)
+                )
+            ],
         ]
 
         # Pass params to daal4py backend

daal4py/sklearn/metrics/_pairwise.py

@@ -18,6 +18,7 @@ import warnings
 from functools import partial
 
 import numpy as np
+from joblib import effective_n_jobs
 from sklearn.exceptions import DataConversionWarning
 from sklearn.metrics import pairwise_distances as pairwise_distances_original
 from sklearn.metrics.pairwise import (
@@ -28,7 +29,6 @@ from sklearn.metrics.pairwise import (
     _parallel_pairwise,
     check_pairwise_arrays,
 )
-from sklearn.utils._joblib import effective_n_jobs
 from sklearn.utils.validation import check_non_negative
 
 try:

daal4py/sklearn/monkeypatch/dispatcher.py

@@ -188,7 +188,7 @@ def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algori
     if verbose and deprecation and sys.stderr is not None:
         sys.stderr.write(
             "oneAPI Data Analytics Library solvers for sklearn enabled: "
-            "https://intelpython.github.io/daal4py/sklearn.html\n"
+            "https://uxlfoundation.github.io/scikit-learn-intelex/\n"
         )
 
 

onedal/_device_offload.py

@@ -15,6 +15,7 @@
 # ==============================================================================
 
 import inspect
+import logging
 from collections.abc import Iterable
 from functools import wraps
 
@@ -34,6 +35,8 @@ else:
 
     SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
 
+logger = logging.getLogger("sklearnex")
+
 
 def supports_queue(func):
     """
@@ -158,12 +161,17 @@ def support_input_format(func):
         else:
             self = None
 
-        # Check if the function is KNeighborsClassifier.fit
+        # KNeighbors*.fit can not be used with raw inputs, ignore `use_raw_input=True`
         override_raw_input = (
             self
             and self.__class__.__name__ in ("KNeighborsClassifier", "KNeighborsRegressor")
             and func.__name__ == "fit"
         )
+        if override_raw_input:
+            pretty_name = f"{self.__class__.__name__}.{func.__name__}"
+            logger.warning(
+                f"Using raw inputs is not supported for {pretty_name}. Ignoring `use_raw_input=True` setting."
+            )
         if _get_config()["use_raw_input"] is True and not override_raw_input:
             if "queue" not in kwargs:
                 usm_iface = getattr(args[0], "__sycl_usm_array_interface__", None)
@@ -190,9 +198,9 @@ def support_input_format(func):
                     result = _convert_to_dpnp(result)
                 return result
 
-        if not get_config().get("transform_output"):
+        if get_config().get("transform_output") in ("default", None):
             input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
-            if input_array_api:
+            if input_array_api and not _is_numpy_namespace(input_array_api):
                 input_array_api_device = data[0].device
                 result = _asarray(result, input_array_api, device=input_array_api_device)
         return result

onedal/ensemble/forest.py

@@ -424,7 +424,9 @@ class BaseForest(BaseEnsemble, metaclass=ABCMeta):
         else:
             result = self.infer(params, model, X)
 
-        return from_table(result.probabilities)
+        # TODO: fix probabilities out of [0, 1] interval on oneDAL side
+        pred = from_table(result.probabilities)
+        return pred.clip(0.0, 1.0)
 
 
 class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):

onedal/tests/utils/_device_selection.py

@@ -63,6 +63,8 @@ def get_memory_usm():
 
 
 def is_dpctl_device_available(targets):
+    if not isinstance(targets, (list, tuple)):
+        raise TypeError("`targets` should be a list or tuple of strings.")
     if dpctl_available:
         for device in targets:
             if device == "cpu" and not dpctl.has_cpu_devices():

onedal/utils/_array_api.py

@@ -40,9 +40,19 @@ if dpnp_available:
         return array
 
 
+def _supports_buffer_protocol(obj):
+    # the array_api standard mandates conversion with the buffer protocol,
+    # which can only be checked via a try-catch in native python
+    try:
+        memoryview(obj)
+    except TypeError:
+        return False
+    return True
+
+
 def _asarray(data, xp, *args, **kwargs):
     """Converted input object to array format of xp namespace provided."""
-    if hasattr(data, "__array_namespace__"):
+    if hasattr(data, "__array_namespace__") or _supports_buffer_protocol(data):
         return xp.asarray(data, *args, **kwargs)
     elif isinstance(data, Iterable):
         if isinstance(data, tuple):
@@ -58,7 +68,12 @@ def _asarray(data, xp, *args, **kwargs):
 
 def _is_numpy_namespace(xp):
     """Return True if xp is backed by NumPy."""
-    return xp.__name__ in {"numpy", "array_api_compat.numpy", "numpy.array_api"}
+    return xp.__name__ in {
+        "numpy",
+        "array_api_compat.numpy",
+        "numpy.array_api",
+        "sklearn.externals.array_api_compat.numpy",
+    }
 
 
 def _get_sycl_namespace(*arrays):