OAP MLlib is an optimized package to accelerate machine learning algorithms in Apache Spark MLlib. It is compatible with Spark MLlib and leverages open source Intel® oneAPI Data Analytics Library (oneDAL) to provide highly optimized algorithms and get most out of CPU and GPU capabilities. It also take advantage of open source Intel® oneAPI Collective Communications Library (oneCCL) to provide efficient communication patterns in multi-node multi-GPU clusters.
OAP MLlib tried to maintain the same API interfaces and produce same results that are identical with Spark MLlib. However due to the nature of float point operations, there may be some small deviation from the original result, we will try our best to make sure the error is within acceptable range. For those algorithms that are not accelerated by OAP MLlib, the original Spark MLlib one will be used.
You can find the all the OAP MLlib documents on the project web page.
Use a pre-built OAP MLlib JAR to get started. You can firstly download OAP package from OAP-JARs-Tarball and extract this Tarball to get oap-mllib-x.x.x-with-spark-x.x.x.jar under oap-1.0.0-bin-spark-3.0.0/jars.
Then you can refer to the following Running section to try out.
Use a pre-built JAR to get started. If you have finished OAP-Installation-Guide, you can find compiled OAP MLlib JAR oap-mllib-x.x.x-with-spark-x.x.x.jar in $HOME/miniconda2/envs/oapenv/oap_jars/.
Then you can refer to the following Running section to try out.
You can also build the package from source code, please refer to Building section.
- CentOS 7.0+, Ubuntu 18.04 LTS+
- Java JRE 8.0+ Runtime
- Apache Spark 3.0.0+
Generally, our common system requirements are the same with Intel® oneAPI Toolkit, please refer to here for details.
Intel® oneAPI Toolkits components used by the project are already included into JAR package mentioned above. There are no extra installations for cluster nodes.
Users usually run Spark application on YARN with client mode. In that case, you only need to add the following configurations in spark-defaults.conf or in spark-submit command line before running.
# absolute path of the jar for uploading
spark.files /path/to/oap-mllib-x.x.x-with-spark-x.x.x.jar
# absolute path of the jar for driver class path
spark.driver.extraClassPath /path/to/oap-mllib-x.x.x-with-spark-x.x.x.jar
# relative path to spark.files, just specify jar name in current dir
spark.executor.extraClassPath ./oap-mllib-x.x.x-with-spark-x.x.x.jar
To use K-means example for sanity check, you need to upload a data file to your HDFS and change related variables in run.sh of kmeans example. Then run the following commands:
$ cd oap-mllib/examples/kmeans
$ ./build.sh
$ ./run.sh
Use Hibench to generate dataset with various profiles, and change related variables in run-XXX.sh script when applicable. Then run the following commands:
$ cd oap-mllib/examples/kmeans-hibench
$ ./build.sh
$ ./run-hibench-oap-mllib.sh
As PySpark-based applications call their Scala couterparts, they shall be supported out-of-box. An example can be found in the Examples section.
We use Apache Maven to manage and build source code. The following tools and libraries are also needed to build OAP MLlib:
- JDK 8.0+
- Apache Maven 3.6.2+
- GNU GCC 4.8.5+
- Intel® oneAPI Toolkits 2021.1.1 Components:
- Data Analytics Library (oneDAL)
- Threading Building Blocks (oneTBB)
- Open Source Intel® oneAPI Collective Communications Library (oneCCL)
Intel® oneAPI Toolkits and its components can be downloaded and install from here. Installation process for oneAPI using Package Managers (YUM (DNF), APT, and ZYPPER) is also available. Generally you only need to install oneAPI Base Toolkit for Linux with all or selected components mentioned above. Instead of using oneCCL included in Intel® oneAPI Toolkits, we prefer to build from open source oneCCL to resolve some bugs.
More details about oneAPI can be found here.
You can also refer to this script and comments in it to install correct oneAPI version and manually setup the environments.
Scala and Java dependency descriptions are already included in Maven POM file.
To clone and build from open source oneCCL, run the following commands:
$ git clone https://github.com/oneapi-src/oneCCL
$ cd oneCCL
$ git checkout beta08
$ mkdir build && cd build
$ cmake ..
$ make -j install
The generated files will be placed in /your/oneCCL_source_code/build/_install
To clone and checkout source code, run the following commands:
$ git clone https://github.com/oap-project/oap-mllib.git
Optional to checkout specific release branch:
$ cd oap-mllib && git checkout ${version}
We rely on environment variables to find required toolchains and libraries. Please make sure the following environment variables are set for building:
| Environment | Description |
|---|---|
| JAVA_HOME | Path to JDK home directory |
| DAALROOT | Path to oneDAL home directory |
| TBB_ROOT | Path to oneTBB home directory |
| CCL_ROOT | Path to oneCCL home directory |
We suggest you to source setvars.sh script into current shell to setup building environments as following:
$ source /opt/intel/inteloneapi/setvars.sh
$ source /your/oneCCL_source_code/build/_install/env/setvars.sh
Be noticed we are using our own built oneCCL instead, we should source oneCCL's setvars.sh to overwrite oneAPI one.
If you prefer to buid your own open source oneDAL, oneTBB versions rather than use the ones included in oneAPI TookKits, you can refer to the related build instructions and manually source setvars.sh accordingly.
To build, run the following commands:
$ cd oap-mllib/mllib-dal
$ ./build.sh
The built JAR package will be placed in target directory with the name oap-mllib-x.x.x-with-spark-x.x.x.jar.
| Example | Description |
|---|---|
| kmeans | K-means example for Scala |
| kmeans-pyspark | K-means example for PySpark |
| kmeans-hibench | Use HiBench-generated input dataset to benchmark K-means performance |
- K-Means (CPU, Experimental)