Before You Begin

End-to-end Example

Read data from a 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 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);

Build and Run Examples

Set up the
oneDAL
environment:
On Linux*:

# Run script to setup CPATH, LIBRARY_PATH and LD_LIBRARY_PATH for oneDAL
source ./env/vars.sh

On Windows*:

# Run script to setup PATH, LIB and INCLUDE for oneDAL
env/vars.bat
Set up the compiler environment for
Intel® oneAPI DPC++/C++ Compiler
. See Get Started with
Intel® oneAPI DPC++/C++ Compiler
for details. For the multi-threaded version of
oneDAL
, set up the environment for Intel® oneAPI Threading Building Blocks.
Build and run DPC++ examples:
You need to have write permissions to the
examples
folder to build examples, and execute permissions to run them. Otherwise, you need to copy
examples/oneapi/dpc
and
examples/oneapi/data
folders to the directory with right permissions. These two folders must be retained in the same directory level relative to each other.
Multi-threaded version of
oneDAL
is used to compile examples.
On Linux*:

# Navigate to DPC++ examples directory and build examples
cd ./examples/oneapi/dpc

# Compile and run Correlation example using Intel® oneAPI DPC++/C++ Compiler
make example=cor_dense_batch 

# Compile all DPC++ examples
make mode=build                          

On Windows*:

# Navigate to DPC++ examples directory and build examples
cd examples/oneapi/dpc

# Compile and run Correlation example using Intel® oneAPI DPC++/C++ Compiler 
nmake libintel64 example=cor_dense_batch+ 

# Compile all DPC++ examples
nmake libintel64 mode=build                           
To see all available parameters of the build procedure, type
make
on Linux* or
nmake
on Windows*.
The resulting example binaries and log files are written to the
_results
directory.

Find More

Notices and Disclaimers