TensorFlow OpenCL

Introduction to TensorFlow OpenCL

TensorFlow is a machine learning algorithm execution framework based on artificial intelligence concepts. We’re working on adding support for OpenCLTM devices to the TensorFlow framework using SYCLTM to give developers access to a wider range of processors. SYCL is an easy free, cross-platform C++ abstraction layer, while OpenCL(Open Computing Language) is a framework for building applications that execute across heterogeneous platforms. OpenCL is a standard parallel computing standard for event and data-based parallelism.

Overview of TensorFlow OpenCL

Over OpenGL ES acceleration, OpenCL provides a 2x inferencing speedup. TensorFlow Lite falls back to OpenGL ES if OpenCL isn’t available, although most mobile GPU vendors supply OpenCL drivers, even if they aren’t exposed to Android app development directly. Higher-level frameworks and compilers are increasingly using OpenCL as an acceleration target. Because OpenCL allows workloads to be shared by CPU and GPU while running the same programs, programmers can take advantage of both by dividing work across the devices. Because the relative rates of processes fluctuate among the devices, this creates a dilemma in selecting how to partition the work. Machine learning has been proposed as a solution to this issue.

CUDA vs OpenCL

Comparison	CUDA	OpenCL
Developed	by NVIDIA Corporation.	developed by Khronos Group
Definition	Compute Unified Device Architecture (CUDA) is a parallel computing design that supports applications that demand a lot of parallel processing.	OpenCL is an open standard that may be used on a wide range of hardware, including desktop and laptop GPUs.
Multiple OS Support	CUDA can run on Windows, Linux, and macOS, but it requires NVIDIA hardware to do it. e.g., Windows XP and later, macOS	OpenCL, on the other hand, can run on practically any operating system and on a wide range of hardware. e.g., Android, FreeBSD, Windows, Linux, macOS e
GPU Support	2 GPUs	Utilize 1GPU
Language support	C, C++, fortran	C, C++
Templates	CUDA is a C API and also constructs.	C++ bindings and has C99
Function	Compiler- build kernels	Kernels at run time.
Libraries	Has a large number of high-performance libraries	Although it has a large number of libraries that may be used on any OpenCL-compliant hardware, it is not as comprehensive as CUDA.
Performance	There is no apparent advantage, as it is depending on code quality, hardware type, and other factors.	There is no apparent advantage, as it is depending on code quality, hardware type, and other factors.

TensorFlow OpenCL examples

There are no known vulnerabilities in TensorFlow-OpenCL and no known vulnerabilities in its dependent libraries. The Apache-2.0 License applies to TensorFlow-OpenCL. This is a permissive license. Permissive licenses offer the fewest limitations and can be used in almost any project.

Blender’s most recent versions support OpenCL rendering. Using the container that has been provided to the Sylabs library, you can run Blender as a graphical programme that will use a local Radeon GPU for OpenCL compute:

$ singularity exec --rocm --bind /etc/OpenCL library://sylabs/demo/blend blender

Set-Up and Run the TensorFlow OpenCL

To add OpenCL support to TensorFlow, we need to use ComputeCpp to create an OpenCL version of TensorFlow. TensorFlow now includes OpenCL support, which can be implemented using SYCL, thanks to Codeplay. TensorFlow is based on the Eigen linear algebra C++ library.

OpenCL installation

sudo apt update
sudo apt install clinfo
clinfo

Install Packages

sudo apt update
sudo apt install git cmake gcc build-essential libpython3-all-dev ocl-icd-opencl-dev opencl-headers openjdk-8-jdk python3 python3-dev python3-pip zlib1g-dev
pip install -U --user numpy==1.14.5 wheel==0.31.1 six==1.11.0 mock==2.0.0 enum34==1.1.6

Configure Set-up

git clone http://github.com/codeplaysoftware/tensorflow
cd tensorflow

Environment variables Set-up

export CC_OPT_FLAGS="-march=native"
export PYTHON_BIN_PATH="/usr/bin/python"
export USE_DEFAULT_PYTHON_LIB_PATH=1
export TF_NEED_JEMALLOC=1
export TF_NEED_MKL=0
export TF_NEED_GCP=0
export TF_NEED_HDFS=0
export TF_ENABLE_XLA=0
export TF_NEED_CUDA=0
export TF_NEED_VERBS=0
export TF_NEED_MPI=0
export TF_NEED_GDR=0
export TF_NEED_AWS=0
export TF_NEED_S3=0
export TF_NEED_KAFKA=0
export TF_DOWNLOAD_CLANG=0
export TF_SET_ANDROID_WORKSPACE=0
export TF_NEED_OPENCL_SYCL=1
export TF_NEED_COMPUTECPP=1

It’s a good idea to run the tests to ensure TensorFlow was constructed successfully. With the following command, you may perform a big set of roughly 1500 tests:

bazel test --test_lang_filters=cc,py --test_timeout 1500 --verbose_failures --jobs=1 --config=sycl --config=opt -- //tensorflow/... -//tensorflow/compiler/... -//tensorflow/contrib/distributions/... -//tensorflow/contrib/lite/... -//tensorflow/contrib/session_bundle/... -//tensorflow/contrib/slim/... -//tensorflow/contrib/verbs/... -//tensorflow/core/distributed_runtime/... -//tensorflow/core/kernels/hexagon/... -//tensorflow/go/... -//tensorflow/java/... -//tensorflow/python/debug/... -//tensorflow/stream_executor/...

Build Tensor Flow

git clone http://github.com/codeplaysoftware/tensorflow
cd tensorflow

Set-Up operations

with tf. Session() as se1:
with tf.device("/gpu:0"):
To execute a code
with tf.Session() as se1:

This line-up will build a new context manager, instructing TensorFlow to use the GPU to accomplish those tasks.

TensorFlow program

Program #1

import tensorflow as tf
>>> he1 = tf.constant('Hi, TensorFlow world!')
>>> se1 = tf.Session()
>>> se1.run(hello)
'Hi, TensorFlow world!'
>>> x = tf.constant(12)
>>> y = tf.constant(22)
>>> se1.run(x + y)
34
>>> se1.close()

Program #2

import sys
import numpy as np
import tensorflow as tf
from datetime import datetime
d_name = sys.argv[1] shape = (int(sys.argv[2]), int(sys.argv[2]))
if d_name == "gpu":
d_name = "/gpu:0"
else:
d_name = "/cpu:0"
with tf.device(d_name):
ran_matrix = tf.random_uniform(shape=shape, minval=0, maxval=1)
d_operation = tf.matmul(ran_matrix, tf.transpose(ran_matrix))
sum_op = tf.reduce_sum(d_operation)
start = datetime.now()
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as session:
res = session.run(sum_op)
print(res)
print("\n" * 6)
print("Shape:", shape, "Device:", d_name)
print("Time done:", datetime.now() - startTime)
print("\n" * 6)

Explanation

To execute
Python name1.py gpu 1500

Output:

OpenCL Acceleration for TensorFlow

OpenCL allows a wide range of accelerators to be used, involving multi-core CPUs, GPUs, DSPs, FPGAs, and specialized hardware like inferencing engines. An OpenCL system is divided into host and device components, with host software developed in a general programming language like C or C++ and generated for running on a host CPU using a normal compiler. TensorFlow to OpenCL translation would necessitate scribbling the kernels in OpenCL C and distinct codebases, both of which would be difficult to maintain. All of it is single-source C++ when using SYCL, therefore it’s possible to integrate the SYCL back-end to TensorFlow in a non-intrusive way.

Let’s see the sample code for registration

namespace tensorflow {
REG5(UnaryOp, CPU, "Sqrt", functor::sqrt, float, Eigen::half, double,
complex64, complex128);
#if GOOGLE_CUDA
REG3(UnaryOp, GPU, "Sqrt", functor::sqrt, float, Eigen::half, double);
#endif
#ifdef TENSORFLOW_USE_SYCL
REG2(UnaryOp, SYCL, "Sqrt", functor::sqrt, float, double);
#endif
}

Conclusion

In general, OpenCL is successful. As a standard, it contains all of the necessary parts, namely run-time code creation and sufficient support for heterogeneous computing. Therefore, in this article, we have seen how tensor flow is acted on OpenCL.

Recommended Articles

This is a guide to TensorFlow OpenCL. Here we discuss the Introduction, overviews, examples with code implementation. You may also have a look at the following articles to learn more –

1. TensorFlow Probability
2. Tensorflow LSTM
3. Caffe TensorFlow
4. TensorFlow Debugging