EDUCBA Logo

EDUCBA

MENUMENU
  • Explore
    • EDUCBA Pro
    • PRO Bundles
    • Featured Skills
    • New & Trending
    • Fresh Entries
    • Finance
    • Data Science
    • Programming and Dev
    • Excel
    • Marketing
    • HR
    • PDP
    • VFX and Design
    • Project Management
    • Exam Prep
    • All Courses
  • Blog
  • Enterprise
  • Free Courses
  • Log in
  • Sign Up
Home Data Science Data Science Tutorials TensorFlow Tutorial TensorFlow OpenCL
 

TensorFlow OpenCL

Updated March 13, 2023

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.

Watch our Demo Courses and Videos

Valuation, Hadoop, Excel, Mobile Apps, Web Development & many more.

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:

1-1

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

Primary Sidebar

Footer

Follow us!
  • EDUCBA FacebookEDUCBA TwitterEDUCBA LinkedINEDUCBA Instagram
  • EDUCBA YoutubeEDUCBA CourseraEDUCBA Udemy
APPS
EDUCBA Android AppEDUCBA iOS App
Blog
  • Blog
  • Free Tutorials
  • About us
  • Contact us
  • Log in
Courses
  • Enterprise Solutions
  • Free Courses
  • Explore Programs
  • All Courses
  • All in One Bundles
  • Sign up
Email
  • [email protected]

ISO 10004:2018 & ISO 9001:2015 Certified

© 2025 - EDUCBA. ALL RIGHTS RESERVED. THE CERTIFICATION NAMES ARE THE TRADEMARKS OF THEIR RESPECTIVE OWNERS.

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
Loading . . .
Quiz
Question:

Answer:

Quiz Result
Total QuestionsCorrect AnswersWrong AnswersPercentage

Explore 1000+ varieties of Mock tests View more

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA
Free Data Science Course

Hadoop, Data Science, Statistics & others

By continuing above step, you agree to our Terms of Use and Privacy Policy.
*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you

EDUCBA Login

Forgot Password?

🚀 Limited Time Offer! - 🎁 ENROLL NOW