Intel® Optimization for TensorFlow* Installation Guide

TensorFlow* is a widely-used machine learning framework in the deep learning arena, demanding efficient utilization of computational resources. In order to take full advantage of Intel® architecture and to extract maximum performance, the TensorFlow framework has been optimized using Intel® Math Kernel Library for Deep Neural Networks (Intel® MKL-DNN) primitives, a popular performance library for deep learning applications. For more information on the optimizations as well as performance data, see this blog post TensorFlow* Optimizations on Modern Intel® Architecture .

Anaconda* has now made it convenient for the AI community to enable high-performance-computing in TensorFlow. Starting from TensorFlow v1.9, Anaconda has and will continue to build TensorFlow using Intel® Math Kernel Library for Deep Neural Networks (Intel® MKL-DNN) primitives to deliver maximum performance in your CPU.

This install guide features several methods to obtain Intel Optimized TensorFlow including off-the-shelf packages or building one from source that are conveniently categorized into Binaries, Docker Images, Build from Source.  

Quick Links

Anaconda

• Linux: Main Channel | Intel Channel | Intel Distribution for Python
• Windows: Main Channel
• MacOS: Main Channel

*Supports Py27, Py36 and Py37

PIP Wheels

• Linux: Py35 | Py36 | Py37

Docker Containers

• Linux: Intel containers | Google DL containers

Build from source

• Linux | Windows

1. Binaries

Install the latest Intel® Optimization for TensorFlow* from Anaconda* Cloud

Available for Linux*, Windows*, MacOS*

TensorFlow* version: 2.2.0

Installation instructions:

If you don't have conda package manager, download and install Anaconda

Linux and MacOS

Open Anaconda prompt and use the following instruction

conda install tensorflow

In case your anaconda channel is not the highest priority channel by default(or you are not sure), use the following command to make sure you get the right TensorFlow with Intel optimizations

conda install tensorflow -c anaconda

Windows

Open Anaconda prompt and use the following instruction

conda install tensorflow-mkl

(or)

conda install tensorflow-mkl -c anaconda

Besides the install method described above, Intel Optimization for TensorFlow is distributed as wheels, docker images and conda package on Intel channel. Follow one of the installation procedures to get Intel-optimized TensorFlow.

 

Note: All binaries distributed by Intel were built against the TensorFlow v2.0 tag in a centOS container with gcc 4.8.5 and glibc 2.17 with the following compiler flags (shown below as passed to bazel*)

--cxxopt=-D_GLIBCXX_USE_CXX11_ABI=0 --copt=-march=corei7-avx --copt=-mtune=core-avx-i --copt=-O3 --copt=-Wformat --copt=-Wformat-security --copt=-fstack-protector --copt=-fPIC --copt=-fpic --linkopt=-znoexecstack --linkopt=-zrelro --linkopt=-znow --linkopt=-fstack-protector

Install the latest Intel® Optimization for TensorFlow* from Intel Channel

Available for Linux*

TensorFlow* version: 2.1.0

Installation instructions:

Open Anaconda prompt and use the following instruction. Available for Python 3.6 and 3.7.

conda install tensorflow -c intel

Get Intel® Optimization for TensorFlow* from Intel® Distribution for Python

Available for Linux*

TensorFlow* version: 2.1.0

Installation instructions:

Open Anaconda prompt and use the following instruction. Available for Python 3.6 and 3.7.

conda create -n IDP intelpython3_full -c intel

(or)

conda create -n IDP intelpython2_full -c intel

Install the Intel® Optimization for TensorFlow* Wheel Into an Existing Python* Installation Through PIP

 

Available for Linux*

TensorFlow version: 2.1.0

Installation instructions:

Note:

For TensorFlow versions 1.13, 1.14 and 1.15 with pip > 20.0, if you experience invalid wheel error, try to downgrade the pip version to <20.0

For e.g

python -m pip install --force-reinstall pip==19.0

Run the below instruction to install the wheel into an existing Python* installation, preferably Intel® Distribution for Python*. Python versions supported are 3.5, 3.6, 3.7

pip install intel-tensorflow

Note than for 1.14.0 install we have fixed a few vulnerabilities and the corrected versions can be installed using the below commands. We identified new CVE issues from curl and GCP support in the previous pypi package release, so we had to introduce a new set of fixed packages in PyPI

Python Version	CMD
python 2.7	pip install https://storage.googleapis.com/intel-optimized-tensorflow/intel_tensorflow-1.14.0-cp27-cp27mu-manylinux1_x86_64.whl
python 3.4	pip install https://storage.googleapis.com/intel-optimized-tensorflow/intel_tensorflow-1.14.0-cp34-cp34m-manylinux1_x86_64.whl
python 3.5	pip install https://storage.googleapis.com/intel-optimized-tensorflow/intel_tensorflow-1.14.0-cp35-cp35m-manylinux1_x86_64.whl
python 3.6	pip install https://storage.googleapis.com/intel-optimized-tensorflow/intel_tensorflow-1.14.0-cp36-cp36m-manylinux1_x86_64.whl
python 3.7	pip install https://storage.googleapis.com/intel-optimized-tensorflow/intel_tensorflow-1.14.0-cp37-cp37m-manylinux1_x86_64.whl

 

Warning on ISA above AVX2:

""This TensorFlow binary is optimized with Intel(R) MKL-DNN to use the following CPU instructions in performance critical operations: <missing_instructions>. To enable them in non-MKL-DNN operations, rebuild TensorFlow with the appropriate compiler flags.""

Older CPUs may not support this version of TensorFlow and may result in "Illegal instruction (core dumped)" error.

2. Docker Images

Get Intel® Optimization for TensorFlow*  Docker Images 

Google DL Containers

Starting version 1.14, Google released DL containers for TensorFlow on CPU optimized with Intel MKL DNN by default. The TensorFlow CPU container names are in the format "tf-cpu.<framework version>" and support Python3.  Below is a sample command to download the docker image locally and launch the container for TensorFlow 1.14

docker run -d -p 8080:8080 -v /home:/home  gcr.io/deeplearning-platform-release/tf-cpu.1-14

This command will start the TensorFlow 1.14 with MKL DNN enabled in detached mode, bind the running Jupyter server to port 8080 on the local machine, and mount local /home directory to /home in the container. The running JupyterLab instance can be accessed at localhost:8080.

To launch an interactive bash instance of the docker container, run the below command

docker run -v /home:/home -it gcr.io/deeplearning-platform-release/tf-cpu.1-14 bash

Obtaining and Running Intel Containers

These docker images are all published at http://hub.docker.com in intelaipg/intel-optimized-tensorflow namespace and can be pulled with the following command:

 

docker pull docker.io/intelaipg/intel-optimized-tensorflow

 

For example, to run the data science container directly, simply

docker run -it -p 8888:8888 intelaipg/intel-optimized-tensorflow

And then go to your browser on http://localhost:8888/

For those who want to navigate through the browser, follow the link

https://hub.docker.com/r/intelaipg/intel-optimized-tensorflow/

Available Container Configurations 

The following tags/configurations are available:

Docker Container Configurations

Configuration	Tags
Python 2.7 with jupyter and sample notebooks	latest latest-mkl 1.14.0-mkl
Python 3.6 with jupyter and sample notebooks	latest-py3 latest-mkl-py3 2.0.0-mkl-py3 1.15.0-mkl-py3 1.15.0-py3

To get the latest Release Notes on Intel-optimized TensorFlow, please refer this article

3. Build from Source

Build TensorFlow from Source with Intel® MKL

Linux build

Building TensorFlow from source is not recommended. However, if instructions provided above do not work due to unsupported ISA, you can always build from source.

Building TensorFlow from source code requires Bazel installation, refer to the instructions here, Installing Bazel.

Installation instructions:

1. Ensure numpy, keras-applications, keras-preprocessing, pip, six, wheel, mock packages are installed in the Python environment where TensorFlow is being built and installed.
2. Clone the TensorFlow source code and checkout a branch of your preference

   git clone https://github.com/tensorflow/tensorflow
   git checkout r2.1
   

3. Run "./configure" from the TensorFlow source directory
4. Execute the following commands to create a pip package that can be used to install the optimized TensorFlow build.
   • PATH can be changed to point to a specific version of GCC compiler:

     export PATH=/PATH//bin:$PATH
     

   • LD_LIBRARY_PATH can also be to new:

     export LD_LIBRARY_PATH=/PATH//lib64:$LD_LIBRARY_PATH
     

   • Set the compiler flags support by the GCC on your machine  to build TensorFlow with Intel® Math Kernel Library (Intel® MKL). Ensure appropriate "march" and "mtune" flags are set. Refer the gcc online docs to know the flags supported by your GCC version.

   • #e.g
     bazel build --config=mkl --cxxopt=-D_GLIBCXX_USE_CXX11_ABI=0 --copt=-march=sandybridge --copt=-mtune=ivybridge --copt=-O3 //tensorflow/tools/pip_package:build_pip_package
     

     (or)

   • Alternatively, set appropriate "Instruction sets" flags you want to compile the library with: 

Flags set in the command below will add AVX, AVX2 and AVX512 instructions which will result in "illegal instruction" errors when you use older CPUs. If you want to build on older CPUs, set the instruction flags accordingly

bazel build --config=mkl -c opt --copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-mavx512f --copt=-mavx512pf --copt=-mavx512cd --copt=-mavx512er //tensorflow/tools/pip_package:build_pip_package

        3. Install the optimized TensorFlow wheel

     bazel-bin/tensorflow/tools/pip_package/build_pip_package ~/path_to_save_wheel

     pip install --upgrade --user ~/path_to_save_wheel/<wheel_name.whl>

Windows Build

Prerequisites

Install the below Visual C++ 2015 build tools from https://visualstudio.microsoft.com/vs/older-downloads/

• Microsoft Visual C++ 2015 Redistributable Update 3
• Microsoft Build Tools 2015 Update 3

Installation

1. Refer to Linux Section and follow Steps 1 through 3
2. To build TensorFlow with MKL-DNN support, we need two additional steps.

• Link.exe on  Visual Studio 2015 causes the linker issue when /WHOLEARCHIVE switch is used. To overcome this issue, install the hotfix to your Visual C++ compiler available at https://support.microsoft.com/en-us/help/4020481/fix-link-exe-crashes-with-a-fatal-lnk1000-error-when-you-use-wholearch  
• Add a PATH environment variable to include MKL runtime lib location that will be created during the build process. The base download location can be specified in the bazel build command by using the --output_base option, and the MKL-DNN libraries will then be downloaded into a directory relative to that base

      set PATH=%PATH%;output_dir\external\mkl_windows\lib   

         3. Bazel build with the with "mkl" flag and the "output_dir" to use the right mkl libs

       bazel --output_base=output_dir build --config=mkl --config=opt //tensorflow/tools/pip_package:build_pip_package

          4. Install the optimized TensorFlow wheel

       bazel-bin\tensorflow\tools\pip_package\build_pip_package C:\temp\path_to_save_wheel
       pip install C:\temp\path_to_save_wheel\<wheel_name.whl>

            

Sanity Check

Once Intel-optimized TensorFlow is installed, running the below command must print "True" if Intel MKLDNN optimizations are present.

 

TensorFlow 1.* versions

python -c "import tensorflow; print(tensorflow.pywrap_tensorflow.IsMklEnabled())"

 

Additional Capabilities and Known Issues

1. Intel-optimized TensorFlow enables Intel MKL calls by default, If at any point you wish to disable Intel MKL primitive calls, this can be disabled by setting TF_DISABLE_MKL flag to 1 before running your TensorFlow script.

   export TF_DISABLE_MKL=1

   However, note that this flag will only disable Intel MKL-DNN calls, but not MKL-ML calls. 

   Although Intel MKL DNN is responsible for most optimizations, certain ops are optimized by MKL-ML library, including matmul, transpose, etc. Disabling MKL-ML calls are not supported by TF_DISABLE_MKL flag at present and Intel is working with Google to add this functionality.  

2. CPU affinity settings in Anaconda's TensorFlow:  If MKL enabled TensorFlow is installed from the anaconda channel (not Intel channel), the "import tensorflow" command sets the KMP_BLOCKTIME and OMP_PROC_BIND environment variables if not already set. However, these variables may have effects on other libraries such as Numpy/Scipy which use OpenMP or MKL. Alternatively, you can either set preferred values or unset them after importing TensorFlow. More details available in the TensorFlow GitHub issue

   import tensorflow # this sets KMP_BLOCKTIME and OMP_PROC_BIND 
   import os 
   # delete the existing values 
   del os.environ['OMP_PROC_BIND'] 
   del os.environ['KMP_BLOCKTIME']

Support

If you have further questions or need support on your workload optimization, Please submit your queries at the TensorFlow GitHub issues with the label "comp:mkl" or the Intel AI Frameworks forum. 

Useful Resources

• General BKMs to maximize performance
• Topology specific BKMs and tutorials
• Intel Model Zoo with pretrained models
• TensorFlow in Anaconda
• Intel-optimized TensorFlow on AWS
• Getting Started with AutoMixedPrecisionMkl

 

Archived Wheels

Version	Wheels(2.7, 3.5, 3.6)
1.6	https://anaconda.org/intel/tensorflow/1.6.0/download/tensorflow-1.6.0-cp27-cp27mu-linux_x86_64.whl (or) */tensorflow-1.6.0-cp35-cp35mu-linux_x86_64.whl (or) */tensorflow-1.6.0-cp36-cp36mu-linux_x86_64.whl
1.9	https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.9.0-cp27-cp27mu-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.9.0-cp35-cp35m-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.9.0-cp36-cp36m-linux_x86_64.whl
1.10	https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.10.0-cp27-cp27mu-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.10.0-cp35-cp35m-linux_x86_64.whl  https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.10.0-cp36-cp36m-linux_x86_64.whl
1.11	https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.11.0-cp27-cp27mu-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.11.0-cp34-cp34m-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.11.0-cp35-cp35m-linux_x86_64.whl https://storage.googleapis.com/intel-optimized-tensorflow/tensorflow-1.11.0-cp36-cp36m-linux_x86_64.whl