End-to-end example#

Below you can find a typical workflow of using oneDAL algorithm on GPU. The example is provided for Principal Component Analysis algorithm (PCA).

The following steps depict how to:

Read the data from CSV file
Run the training and inference operations for PCA
Access intermediate results obtained at the training stage

Include the following header that makes all oneDAL declarations available.

#include "oneapi/dal.hpp"

/* Standard library headers required by this example */
#include <cassert>
#include <iostream>

Create a SYCL* queue with the desired device selector. In this case, GPU selector is used:
```
const auto queue = sycl::queue{ sycl::gpu_selector{} };
```
Since all oneDAL declarations are in the oneapi::dal namespace, import all declarations from the oneapi namespace to use dal instead of oneapi::dal for brevity:
```
using namespace oneapi;
```

Use CSV data source to read the data from the CSV file into a table:

const auto data = dal::read<dal::table>(queue, dal::csv::data_source{"data.csv"});

Create a PCA descriptor, configure its parameters, and run the training algorithm on the data loaded from CSV.

const auto pca_desc = dal::pca::descriptor<float>
   .set_component_count(3)
   .set_deterministic(true);

const dal::pca::train_result train_res = dal::train(queue, pca_desc, data);

Print the learned eigenvectors:

const dal::table eigenvectors = train_res.get_eigenvectors();

const auto acc = dal::row_accessor<const float>{eigenvectors};
for (std::int64_t i = 0; i < eigenvectors.row_count(); i++) {

   /* Get i-th row from the table, the eigenvector stores pointer to USM */
   const dal::array<float> eigenvector = acc.pull(queue, {i, i + 1});
   assert(eigenvector.get_count() == eigenvectors.get_column_count());

   std::cout << i << "-th eigenvector: ";
   for (std::int64_t j = 0; j < eigenvector.get_count(); j++) {
      std::cout << eigenvector[j] << " ";
   }
   std::cout << std::endl;
}

Use the trained model for inference to reduce dimensionality of the data:

const dal::pca::model model = train_res.get_model();

const dal::table data_transformed =
   dal::infer(queue, pca_desc, data).get_transformed_data();

assert(data_transformed.column_count() == 3);