@minor@

Author: Nikita Kulikov

onedal/cluster/dbscan.py

@@ -81,6 +81,7 @@ def _fit(self, X, y, sample_weight, module, queue):
             ).ravel()
         else:
             self.core_sample_indices_ = np.array([], dtype=np.intc)
+        self.core_sample_indices_ = self.core_sample_indices_.astype(np.intc)
         self.components_ = np.take(X, self.core_sample_indices_, axis=0)
         self.n_features_in_ = X.shape[1]
         return self

onedal/cluster/kmeans.py

@@ -91,9 +91,10 @@ def _check_params_vs_input(
         self, X_table, policy, default_n_init=10, dtype=np.float32
     ):
         # n_clusters
-        if X_table.shape[0] < self.n_clusters:
+        X_row_count = X_table.get_row_count()
+        if X_row_count < self.n_clusters:
             raise ValueError(
-                f"n_samples={X_table.shape[0]} should be >= n_clusters={self.n_clusters}."
+                f"n_samples={X_row_count} should be >= n_clusters={self.n_clusters}."
             )
 
         # tol
@@ -182,7 +183,7 @@ def _init_centroids_custom(
         elif _is_arraylike_not_scalar(init):
             centers = np.asarray(init)
             assert centers.shape[0] == n_clusters
-            assert centers.shape[1] == X_table.column_count
+            assert centers.shape[1] == X_table.get_column_count()
             centers = _convert_to_supported(policy, init)
             centers_table = to_table(centers)
         else:
@@ -221,10 +222,6 @@ def _init_centroids_generic(self, X, init, random_state, policy, dtype=np.float3
     def _fit_backend(self, X_table, centroids_table, module, policy, dtype=np.float32):
         params = self._get_onedal_params(dtype)
 
-        # TODO: check all features for having correct type
-        meta = _backend.get_table_metadata(X_table)
-        assert meta.get_npy_dtype(0) == dtype
-
         result = module.train(policy, params, X_table, centroids_table)
 
         return (
@@ -238,7 +235,7 @@ def _fit(self, X, module, queue=None):
         policy = self._get_policy(queue, X)
         _, X_table, dtype = self._get_params_and_input(X, policy)
 
-        self.n_features_in_ = X_table.column_count
+        self.n_features_in_ = X_table.get_column_count()
 
         best_model, best_n_iter = None, None
         best_inertia, best_labels = None, None

onedal/common/dispatch_utils.hpp

@@ -15,7 +15,7 @@
 *******************************************************************************/
 
 #pragma once
-#include <iostream>
+
 #include <pybind11/pybind11.h>
 
 #include "oneapi/dal/train.hpp"
@@ -79,13 +79,8 @@ struct train_ops {
 
     template <typename Float, typename Method, typename... Args>
     auto operator()(const pybind11::dict& params) {
-        std::cout << "C++: Function: " << __PRETTY_FUNCTION__ << std::endl;
-        std::cout << "C++: Before training" << std::endl;
         auto desc = ops.template operator()<Float, Method, Task, Args...>(params);
-        std::cout << "C++: Descriptor has been created" << std::endl;
-        auto result = dal::train(policy, desc, input);
-        std::cout << "C++: Algorithms has been called" << std::endl;
-        return result;
+        return dal::train(policy, desc, input);
     }
 
     Policy policy;

onedal/data_management/array/array.cpp

@@ -20,6 +20,7 @@
 #include "oneapi/dal/array.hpp"
 #include "oneapi/dal/common.hpp"
 #include "oneapi/dal/detail/common.hpp"
+#include "oneapi/dal/detail/array_utils.hpp"
 
 #include "onedal/common.hpp"
 
@@ -46,6 +47,47 @@ inline void check_access(const dal::array<Type>& arr, std::int64_t idx) {
     }
 }
 
+template <typename T>
+inline auto get_policy(const dal::array<T>& arr) {
+    return dal::detail::get_impl(arr).get_policy();
+}
+
+template <typename Policy>
+constexpr inline bool is_host_policy_v = dal::detail::is_one_of_v<Policy, //
+                        detail::default_host_policy, detail::host_policy>;
+
+template <typename InpPolicy, typename OutPolicy>
+inline bool need_copy(const InpPolicy& inp, const OutPolicy& out) {
+    using out_policy_t = std::decay_t<decltype(inp)>;
+    using inp_policy_t = std::decay_t<decltype(out)>;
+    constexpr bool is_inp_host = is_host_policy_v<inp_policy_t>;
+    constexpr bool is_out_host = is_host_policy_v<out_policy_t>;
+    constexpr bool result = !(is_inp_host && is_out_host);
+    return result;
+}
+
+// TODO: Check for the same policy
+template <typename Policy, typename T>
+inline dal::array<T> to_policy(const Policy& out, const dal::array<T>& source) {
+    return std::visit([&](const auto& inp) -> dal::array<T> {
+        if (need_copy(inp, out)) {
+            return detail::copy(out, source); 
+        }
+        else {
+            return dal::array<T>{ source };
+        }
+    }, get_policy(source));
+}
+
+template <typename Policy, typename Array>
+inline void instantiate_to_policy(py::class_<Array>& py_array) {
+    constexpr const char name[] = "to_policy";
+    py_array.def(name, [](const Array& source, const Policy& policy) {
+        auto result = to_policy(policy, source);
+        return py::cast( std::move(result) );
+    });
+}
+
 template <typename Type>
 void instantiate_array_by_type(py::module& pm) {
     const auto name = name_array<Type>();
@@ -67,6 +109,9 @@ void instantiate_array_by_type(py::module& pm) {
     py_array.def("__len__", &array_t::get_count);
     py_array.def("get_count", &array_t::get_count);
     py_array.def("has_mutable_data", &array_t::has_mutable_data);
+    py_array.def("has_data", [](const array_t& array) -> bool {
+        return array.get_count() > std::int64_t(0l);
+    });
     py_array.def("get_slice", [](const array_t& array, 
             std::int64_t first, std::int64_t last) -> array_t {
         constexpr std::int64_t zero = 0l;
@@ -92,7 +137,7 @@ void instantiate_array_by_type(py::module& pm) {
     py_array.def("get_policy", [](const array_t& arr) -> py::object {
         return std::visit([](const auto& policy) -> py::object {
             return py::cast( policy );
-        }, dal::detail::get_impl(arr).get_policy());
+        }, get_policy(arr));
     });
     py_array.def("__getitem__", [](const array_t& arr, std::int64_t idx) -> Type {
         check_access<Type, false>(arr, idx);
@@ -105,6 +150,11 @@ void instantiate_array_by_type(py::module& pm) {
     py_array.def_property_readonly("__is_onedal_array__", [](const array_t&) -> bool {
         return true;
     });
+    instantiate_to_policy<detail::host_policy>(py_array);
+    instantiate_to_policy<detail::default_host_policy>(py_array);
+#ifdef ONEDAL_DATA_PARALLEL
+    instantiate_to_policy<detail::data_parallel_policy>(py_array);
+#endif // ONEDAL_DATA_PARALLEL
 }
 
 template <typename... Types>

onedal/data_management/table/table.cpp

@@ -68,14 +68,6 @@ void instantiate_table(py::module& pm) {
     py_table.def(py::init<dal::homogen_table>());
     py_table.def(py::init<dal::heterogen_table>());
 
-    py_table.def("has_data", &dal::table::has_data);
-
-    py_table.def("__repr__", [](const dal::table& t) {
-        std::stringstream stream;
-        stream << "oneDAL table of kind: " << t.get_kind();
-        return stream.str();
-    });
-
     return instantiate_table_iface(py_table);
 }
 

onedal/data_management/table/table_iface.hpp

@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include <string>
 #include <cstdint>
+#include <sstream>
 
 #include <pybind11/pybind11.h>
 
@@ -48,9 +50,25 @@ inline void instantiate_table_iface(py::class_<Table>& py_table) {
     py_table.def("get_row_count", &Table::get_row_count);
     py_table.def("get_data_layout", &Table::get_data_layout);
     py_table.def("get_column_count", &Table::get_column_count);
+    py_table.def("has_data", [](const Table& t) -> bool {
+        return t.has_data();
+    });
     py_table.def("get_kind", [](const Table& t) -> table_kind {
         return static_cast<table_kind>(t.get_kind());
     });
+    py_table.def_property_readonly("__is_onedal_table__", [](const Table&) -> bool {
+        return true;
+    });
+
+    py_table.def("__repr__", [](const Table& t) {
+        std::stringstream stream;
+
+        static const auto type = py::type::handle_of<Table>();
+        static const auto name = std::string{ py::str(type) };
+        stream << "<oneDAL table of kind: " << t.get_kind();
+        stream << " packed into " << name << '>';
+        return stream.str();
+    });
 }
 
 } // namespace oneapi::dal::python::data_management

onedal/datatypes/_data_conversion.py

@@ -24,9 +24,6 @@
 
 import onedal.interoperability as interop
 
-to_table_one = interop.to_table
-from_table_one = interop.from_table
-
 try:
     import dpctl
     import dpctl.tensor as dpt
@@ -42,10 +39,17 @@ def _apply_and_pass(func, *args):
     return tuple(map(func, args))
 
 
+def from_table_one(table):
+    return interop.from_table(table)
+
+
 def from_table(*args):
     return _apply_and_pass(from_table_one, *args)
 
 
+def to_table_one(table):
+    return interop.to_table(table)
+
 def convert_one_to_table(arg):
     return to_table_one(make2d(arg))
 

onedal/interoperability/buffer/buffer_and_table.cpp

@@ -13,7 +13,7 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
-#include <iostream>
+
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 

onedal/interoperability/csr_table.py

@@ -1,4 +1,5 @@
 import onedal
+import numpy as np
 
 from .array import to_array, from_array
 
@@ -7,6 +8,7 @@
 table = onedal._backend.data_management.table
 csr_table = onedal._backend.data_management.csr_table
 csr_kind = onedal._backend.data_management.table_kind.csr
+sparse_indexing = onedal._backend.data_management.sparse_indexing
 
 def is_native_csr(entity) -> bool:
     if isinstance(entity, table):
@@ -31,14 +33,26 @@ def to_csr_table_native(entity) -> csr_table:
     assert is_native_csr(entity)
     return csr_table(entity)
 
+def to_typed_array(x, dtypes = [np.int64]):
+    result = x
+    if x.dtype not in list(dtypes):
+        result = x.astype(dtypes[0])
+    assert result.dtype in dtypes
+    return to_array(result)
+
 # Converting python entity to table
+# TODO: Implement smarter logic
 def to_csr_table_python(entity) -> csr_table:
     assert isspmatrix_csr(entity)
     _, col_count = entity.shape
-    ids = to_array(entity.indices)
-    ofs = to_array(entity.indptr)
-    nz = to_array(entity.nnz)
-    result = csr_table(nz, ids, ofs, col_count)
+    ids = to_typed_array(entity.indices)
+    print(ids.get_policy())
+    ofs = to_typed_array(entity.indptr)
+    print(ofs.get_policy())
+    nz = to_array(entity.data)
+    print(nz.get_policy())
+    result = csr_table(nz, ids, ofs, \
+        col_count, sparse_indexing.zero_based)
     assert_table(result, entity)
     return result
 

onedal/interoperability/dlpack/array_interop.py

@@ -3,7 +3,6 @@
 from .dlpack_utils import is_dlpack_entity, is_nd
 
 wrap_to_array = onedal._backend.interop.dlpack.wrap_to_array
-wrap_from_array = onedal._backend.interop.dlpack.wrap_from_array
 
 # TODO: implement more complex logic of
 # checking shape & strides in entity
@@ -15,18 +14,3 @@ def is_dlpack_array(entity) -> bool:
 def to_array(entity):
     assert is_dlpack_array(entity)
     return wrap_to_array(entity)
-
-class fake_dlpack_array:
-    def __init__(self, array):
-        self.array = array
-
-    @property
-    def __dlpack__(self):
-        if not hasattr(self, "dlpack") or self.dlpack is None:
-            self.dlpack = wrap_from_array(self.array)
-        return self.dlpack
-
-def from_array(array):
-    result = fake_dlpack_array(array)
-    assert is_dlpack_array(result)
-    return result