Fix for devices that does not support fp64 (#1198)

Author: KulikovNikita

onedal/datatypes/_data_conversion.py

@@ -14,14 +14,19 @@
 # limitations under the License.
 # ===============================================================================
 
+import warnings
 from onedal import _backend
 from daal4py.sklearn._utils import make2d
 
 
-def from_table(*args):
+def _apply_and_pass(func, *args):
     if len(args) == 1:
-        return _backend.from_table(args[0])
-    return (_backend.from_table(item) for item in args)
+        return func(args[0])
+    return tuple(map(func, args))
+
+
+def from_table(*args):
+    return _apply_and_pass(_backend.from_table, *args)
 
 
 def convert_one_to_table(arg):
@@ -30,9 +35,7 @@ def convert_one_to_table(arg):
 
 
 def to_table(*args):
-    if len(args) == 1:
-        return convert_one_to_table(args[0])
-    return (convert_one_to_table(item) for item in args)
+    return _apply_and_pass(convert_one_to_table, *args)
 
 
 from onedal import _is_dpc_backend
@@ -42,33 +45,34 @@ def to_table(*args):
 
     from ..common._policy import _HostInteropPolicy
 
-    def _convert_to_supported_impl(policy, *data):
+    def _convert_to_supported(policy, *data):
+        def func(x):
+            return x
+
         # CPUs support FP64 by default
         if isinstance(policy, _HostInteropPolicy):
-            return data
+            return _apply_and_pass(func, *data)
 
         # It can be either SPMD or DPCPP policy
         device = policy._queue.sycl_device
 
         def convert_or_pass(x):
-            if x.dtype is np.float64:
+            if x.dtype == np.float64:
+                warnings.warn("Data will be converted into float32 from "
+                              "float64 because device does not support it",
+                              RuntimeWarning, )
                 return x.astype(np.float32)
             else:
                 return x
 
         if not device.has_aspect_fp64:
-            return (convert_or_pass(x) for x in data)
-        else:
-            return data
-else:
-    def _convert_to_supported_impl(policy, *data):
-        return data
+            func = convert_or_pass
 
+        return _apply_and_pass(func, *data)
 
-def _convert_to_supported(policy, *data):
-    res = _convert_to_supported_impl(policy, *data)
+else:
+    def _convert_to_supported(policy, *data):
+        def func(x):
+            return x
 
-    if len(data) == 1:
-        return res[0]
-    else:
-        return res
+        return _apply_and_pass(func, *data)

onedal/datatypes/data_conversion.cpp

@@ -61,7 +61,7 @@ inline dal::homogen_table convert_to_homogen_impl(PyArrayObject *np_data) {
     if (array_numdims(np_data) > 2) {
         throw std::runtime_error("Input array has wrong dimensionality (must be 2d).");
     }
-    T *data_pointer = reinterpret_cast<T *>(array_data(np_data));
+    T* const data_pointer = reinterpret_cast<T* const>(array_data(np_data));
     // TODO: check safe cast from int to std::int64_t
     const std::int64_t row_count = static_cast<std::int64_t>(array_size(np_data, 0));
     if (array_numdims(np_data) == 2) {

onedal/datatypes/numpy_helpers.hpp

@@ -63,20 +63,20 @@
 
 #define SET_NPY_FEATURE(_T, _FUNCT, _EXCEPTION) \
     switch (_T) {                               \
-        case NPY_DOUBLE:                        \
-        case NPY_CDOUBLE:                       \
-        case NPY_DOUBLELTR:                     \
-        case NPY_CDOUBLELTR: {                  \
-            _FUNCT(double);                     \
-            break;                              \
-        }                                       \
         case NPY_FLOAT:                         \
         case NPY_CFLOAT:                        \
         case NPY_FLOATLTR:                      \
         case NPY_CFLOATLTR: {                   \
             _FUNCT(float);                      \
             break;                              \
         }                                       \
+        case NPY_DOUBLE:                        \
+        case NPY_CDOUBLE:                       \
+        case NPY_DOUBLELTR:                     \
+        case NPY_CDOUBLELTR: {                  \
+            _FUNCT(double);                     \
+            break;                              \
+        }                                       \
         case NPY_INT32: {                       \
             _FUNCT(std::int32_t);               \
             break;                              \

onedal/decomposition/pca.py

@@ -14,13 +14,13 @@
 # limitations under the License.
 #===============================================================================
 
+import numpy as np
+
 from onedal import _backend
 from ..common._policy import _get_policy
-from ..datatypes._data_conversion import from_table, to_table
+from ..datatypes._data_conversion import from_table, to_table, _convert_to_supported
 from daal4py.sklearn._utils import sklearn_check_version
 
-import numpy as np
-
 
 class PCA():
     def __init__(
@@ -37,7 +37,7 @@ def __init__(
     def get_onedal_params(self, data):
         return {
             'fptype':
-                'float' if data.dtype is np.dtype('float32') else 'double',
+                'float' if data.dtype == np.float32 else 'double',
             'method': self.method,
             'n_components': self.n_components,
             'is_deterministic': self.is_deterministic
@@ -48,6 +48,8 @@ def fit(self, X, y, queue):
         n_sf_min = min(n_samples, n_features)
 
         policy = _get_policy(queue, X, y)
+
+        X, y = _convert_to_supported(policy, X, y)
         params = self.get_onedal_params(X)
         cov_result = _backend.covariance.compute(
             policy,
@@ -97,8 +99,10 @@ def _create_model(self):
 
     def predict(self, X, queue):
         policy = _get_policy(queue, X)
-        params = self.get_onedal_params(X)
         model = self._create_model()
+
+        X = _convert_to_supported(policy, X)
+        params = self.get_onedal_params(X)
         result = _backend.decomposition.dim_reduction.infer(policy,
                                                             params,
                                                             model,

onedal/ensemble/forest.py

@@ -40,7 +40,8 @@
     _check_X_y,
     _check_array,
     _column_or_1d,
-    _check_n_features
+    _check_n_features,
+    _convert_to_supported
 )
 
 from ..common._mixin import ClassifierMixin, RegressorMixin
@@ -204,7 +205,7 @@ def _get_onedal_params(self, data):
                     self.min_samples_split * n_samples)))
 
         onedal_params = {
-            'fptype': 'float' if data.dtype is np.dtype('float32') else 'double',
+            'fptype': 'float' if data.dtype == np.float32 else 'double',
             'method': self.algorithm,
             'infer_mode': self.infer_mode,
             'voting_mode': self.voting_mode,
@@ -350,6 +351,8 @@ def _fit(self, X, y, sample_weight, module, queue):
         if not sklearn_check_version('1.0'):
             self.n_features_ = self.n_features_in_
         policy = self._get_policy(queue, X, y, sample_weight)
+
+        X, y, sample_weight = _convert_to_supported(policy, X, y, sample_weight)
         params = self._get_onedal_params(X)
         train_result = module.train(
             policy, params, *to_table(X, y, sample_weight))
@@ -380,9 +383,10 @@ def _predict(self, X, module, queue):
                          force_all_finite=True, accept_sparse=False)
         _check_n_features(self, X, False)
         policy = self._get_policy(queue, X)
-        params = self._get_onedal_params(X)
 
         model = self._onedal_model
+        X = _convert_to_supported(policy, X)
+        params = self._get_onedal_params(X)
         result = module.infer(policy, params, model, to_table(X))
         y = from_table(result.responses)
         return y
@@ -393,6 +397,7 @@ def _predict_proba(self, X, module, queue):
                          force_all_finite=True, accept_sparse=False)
         _check_n_features(self, X, False)
         policy = self._get_policy(queue, X)
+        X = _convert_to_supported(policy, X)
         params = self._get_onedal_params(X)
         params['infer_mode'] = 'class_probabilities'
 

onedal/linear_model/linear_model.py

@@ -49,7 +49,7 @@ def _get_policy(self, queue, *data):
     def _get_onedal_params(self, dtype=np.float32):
         intercept = 'intercept|' if self.fit_intercept else ''
         return {
-            'fptype': 'float' if dtype is np.float32 else 'double',
+            'fptype': 'float' if dtype == np.float32 else 'double',
             'method': self.algorithm, 'intercept': self.fit_intercept,
             'result_option': (intercept + 'coefficients'),
         }
@@ -63,20 +63,19 @@ def _fit(self, X, y, module, queue):
 
         dtype = get_dtype(X_loc)
         if dtype not in [np.float32, np.float64]:
-            X_loc = X_loc.astype(np.float64, copy=self.copy_X)
             dtype = np.float64
+            X_loc = X_loc.astype(dtype, copy=self.copy_X)
 
         y_loc = np.asarray(y_loc).astype(dtype=dtype)
 
         # Finiteness is checked in the sklearnex wrapper
         X_loc, y_loc = _check_X_y(
             X_loc, y_loc, force_all_finite=False, accept_2d_y=True)
 
-        params = self._get_onedal_params(dtype)
-
         self.n_features_in_ = _num_features(X_loc, fallback_1d=True)
 
         X_loc, y_loc = _convert_to_supported(policy, X_loc, y_loc)
+        params = self._get_onedal_params(get_dtype(X_loc))
         X_table, y_table = to_table(X_loc, y_loc)
 
         result = module.train(policy, params, X_table, y_table)
@@ -92,7 +91,7 @@ def _fit(self, X, y, module, queue):
 
         return self
 
-    def _create_model(self, module):
+    def _create_model(self, module, policy):
         m = module.model()
 
         coefficients = self.coef_
@@ -137,6 +136,8 @@ def _create_model(self, module):
         if self.fit_intercept:
             packed_coefficients[:, 0][:, np.newaxis] = intercept
 
+        packed_coefficients = _convert_to_supported(policy, packed_coefficients)
+
         m.packed_coefficients = to_table(packed_coefficients)
 
         self._onedal_model = m
@@ -158,15 +159,14 @@ def _predict(self, X, module, queue):
                              force_all_finite=False, ensure_2d=False)
         _check_n_features(self, X_loc, False)
 
-        params = self._get_onedal_params(X_loc)
-
         if hasattr(self, '_onedal_model'):
             model = self._onedal_model
         else:
-            model = self._create_model(module)
+            model = self._create_model(module, policy)
 
         X_loc = make2d(X_loc)
         X_loc = _convert_to_supported(policy, X_loc)
+        params = self._get_onedal_params(get_dtype(X_loc))
 
         X_table = to_table(X_loc)
         result = module.infer(policy, params, model, X_table)