build-instruction.md

   1 # Build OpenVINO™ Inference Engine
   2
   3 ## Contents
   4
   5 - [Introduction](#introduction)
   6 - [Build on Linux\* Systems](#build-on-linux-systems)
   7   - [Software Requirements](#software-requirements)
   8   - [Build Steps](#build-steps)
   9   - [Additional Build Options](#additional-build-options)
  10 - [Build for Raspbian* Stretch OS](#build-for-raspbian-stretch-os)
  11   - [Hardware Requirements](#hardware-requirements)
  12   - [Native Compilation](#native-compilation)
  13   - [Cross Compilation Using Docker\*](#cross-compilation-using-docker)
  14   - [Additional Build Options](#additional-build-options-1)
  15 - [Build on Windows* Systems](#build-on-windows-systems)
  16   - [Software Requirements](#software-requirements-1)
  17   - [Build Steps](#build-steps-1)
  18   - [Additional Build Options](#additional-build-options-2)
  19   - [Building Inference Engine with Ninja* Build System](#building-inference-engine-with-ninja-build-system)
  20 - [Build on macOS\* Systems](#build-on-macos-systems)
  21   - [Software Requirements](#software-requirements-2)
  22   - [Build Steps](#build-steps-2)
  23   - [Additional Build Options](#additional-build-options-3)
  24 - [Build on Android\* Systems](#build-on-android-systems)
  25   - [Software Requirements](#software-requirements-3)
  26   - [Build Steps](#build-steps-3)
  27 - [Use Custom OpenCV Builds for Inference Engine](#use-custom-opencv-builds-for-inference-engine)
  28 - [Add Inference Engine to Your Project](#add-inference-engine-to-your-project)
  29 - [(Optional) Additional Installation Steps for the Intel® Movidius™ Neural Compute Stick and Neural Compute Stick 2](#optional-additional-installation-steps-for-the-intel-movidius-neural-compute-stick-and-neural-compute-stick-2)
  30   - [For Linux, Raspbian Stretch* OS](#for-linux-raspbian-stretch-os)
  31 - [Next Steps](#next-steps)
  32 - [Additional Resources](#additional-resources)
  33
  34 ## Introduction
  35
  36 The Inference Engine can infer models in different formats with various input
  37 and output formats.
  38
  39 The open source version of Inference Engine includes the following plugins:
  40
  41 | PLUGIN               | DEVICE TYPES |
  42 | ---------------------| -------------|
  43 | CPU plugin           | Intel® Xeon® with Intel® AVX2 and AVX512, Intel® Core™ Processors with Intel® AVX2, Intel® Atom® Processors with Intel® SSE |
  44 | GPU plugin           | Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics |
  45 | GNA plugin           | Intel® Speech Enabling Developer Kit, Amazon Alexa\* Premium Far-Field Developer Kit, Intel® Pentium® Silver processor J5005, Intel® Celeron® processor J4005, Intel® Core™ i3-8121U processor |
  46 | MYRIAD plugin        | Intel® Movidius™ Neural Compute Stick powered by the Intel® Movidius™ Myriad™ 2, Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X |
  47 | Heterogeneous plugin | Heterogeneous plugin enables computing for inference on one network on several Intel® devices. |
  48
  49 Inference Engine plugin for Intel® FPGA is distributed only in a binary form,
  50 as a part of [Intel® Distribution of OpenVINO™].
  51
  52 ## Build on Linux\* Systems
  53
  54 The software was validated on:
  55 - Ubuntu\* 18.04 (64-bit) with default GCC\* 7.5.0
  56 - Ubuntu\* 16.04 (64-bit) with default GCC\* 5.4.0
  57 - CentOS\* 7.4 (64-bit) with default GCC\* 4.8.5
  58
  59 ### Software Requirements
  60 - [CMake]\* 3.11 or higher
  61 - GCC\* 4.8 or higher to build the Inference Engine
  62 - Python 3.5 or higher for Inference Engine Python API wrapper
  63 - (Optional) [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441].
  64
  65 ### Build Steps
  66 1. Clone submodules:
  67     ```sh
  68     cd openvino
  69     git submodule update --init --recursive
  70     ```
  71 2. Install build dependencies using the `install_dependencies.sh` script in the
  72    project root folder.
  73    ```sh
  74    chmod +x install_dependencies.sh
  75    ```
  76    ```sh
  77    ./install_dependencies.sh
  78    ```
  79 3. By default, the build enables the Inference Engine GPU plugin to infer models
  80    on your Intel® Processor Graphics. This requires you to
  81    [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]
  82    before running the build. If you don't want to use the GPU plugin, use the
  83    `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
  84    Intel® Graphics Compute Runtime for OpenCL™ Driver.
  85 4. Create a build folder:
  86 ```sh
  87   mkdir build && cd build
  88 ```
  89 5. Inference Engine uses a CMake-based build system. In the created `build`
  90    directory, run `cmake` to fetch project dependencies and create Unix
  91    makefiles, then run `make` to build the project:
  92 ```sh
  93   cmake -DCMAKE_BUILD_TYPE=Release ..
  94   make --jobs=$(nproc --all)
  95 ```
  96
  97 ### Additional Build Options
  98
  99 You can use the following additional build options:
 100
 101 - The default build uses an internal JIT GEMM implementation.
 102
 103 - To switch to an OpenBLAS\* implementation, use the `GEMM=OPENBLAS` option with
 104   `BLAS_INCLUDE_DIRS` and `BLAS_LIBRARIES` CMake options to specify a path to the
 105   OpenBLAS headers and library. For example, the following options on CentOS\*:
 106   `-DGEMM=OPENBLAS -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DBLAS_LIBRARIES=/usr/lib64/libopenblas.so.0`.
 107
 108 - To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL`
 109   and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to unpacked
 110   MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be downloaded
 111   from the Intel® [MKL-DNN repository].
 112
 113 - Threading Building Blocks (TBB) is used by default. To build the Inference
 114   Engine with OpenMP\* threading, set the `-DTHREADING=OMP` option.
 115
 116 - Required versions of TBB and OpenCV packages are downloaded automatically by
 117   the CMake-based script. If you want to use the automatically downloaded
 118   packages but you already have installed TBB or OpenCV packages configured in
 119   your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
 120   environment variables before running the `cmake` command, otherwise they
 121   will not be downloaded and the build may fail if incompatible versions were
 122   installed.
 123
 124 - If the CMake-based build script can not find and download the OpenCV package
 125   that is supported on your platform, or if you want to use a custom build of
 126   the OpenCV library, refer to the
 127   [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
 128   section for details.
 129
 130 - To build the Python API wrapper:
 131   1. Install all additional packages listed in the
 132      `/inference-engine/ie_bridges/python/requirements.txt` file:
 133      ```sh
 134      pip install -r requirements.txt
 135      ```
 136   2. Use the `-DENABLE_PYTHON=ON` option. To specify an exact Python version, use the following
 137      options:
 138      ```
 139      -DPYTHON_EXECUTABLE=`which python3.7` \
 140      -DPYTHON_LIBRARY=/usr/lib/x86_64-linux-gnu/libpython3.7m.so \
 141      -DPYTHON_INCLUDE_DIR=/usr/include/python3.7
 142      ```
 143
 144 - To switch the CPU and GPU plugins off/on, use the `cmake` options
 145   `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
 146
 147 - nGraph-specific compilation options:
 148   `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
 149   `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
 150
 151 ## Build for Raspbian Stretch* OS
 152
 153 > **NOTE**: Only the MYRIAD plugin is supported.
 154
 155 ### Hardware Requirements
 156 * Raspberry Pi\* 2 or 3 with Raspbian\* Stretch OS (32-bit). Check that it's CPU supports ARMv7 instruction set (`uname -m` command returns `armv7l`).
 157
 158   > **NOTE**: Despite the Raspberry Pi\* CPU is ARMv8, 32-bit OS detects ARMv7 CPU instruction set. The default `gcc` compiler applies ARMv6 architecture flag for compatibility with lower versions of boards. For more information, run the `gcc -Q --help=target` command and refer to the description of the `-march=` option.
 159
 160 You can compile the Inference Engine for Raspberry Pi\* in one of the two ways:
 161 * [Native Compilation](#native-compilation), which is the simplest way, but time-consuming
 162 * [Cross Compilation Using Docker*](#cross-compilation-using-docker), which is the recommended way
 163
 164 ### Native Compilation
 165 Native compilation of the Inference Engine is the most straightforward solution. However, it might take at least one hour to complete on Raspberry Pi\* 3.
 166
 167 1. Install dependencies:
 168
 169   ```bash
 170   sudo apt-get update
 171   sudo apt-get install -y git cmake libusb-1.0-0-dev
 172   ```
 173
 174 2. Go to the cloned `openvino` repository:
 175
 176   ```bash
 177   cd openvino
 178   ```
 179
 180 3. Initialize submodules:
 181
 182   ```bash
 183   git submodule update --init --recursive
 184   ```
 185
 186 4. Create a build folder:
 187
 188   ```bash
 189   mkdir build && cd build
 190   ```
 191
 192 5. Build the Inference Engine:
 193
 194   ```bash
 195   cmake -DCMAKE_BUILD_TYPE=Release \
 196         -DENABLE_SSE42=OFF \
 197         -DTHREADING=SEQ \
 198         -DENABLE_GNA=OFF .. && make
 199   ```
 200
 201 ### Cross Compilation Using Docker*
 202
 203   This compilation was tested on the following configuration:
 204
 205   * Host: Ubuntu\* 18.04 (64-bit, Intel® Core™ i7-6700K CPU @ 4.00GHz × 8)
 206   * Target: Raspbian\* Stretch (32-bit, ARMv7, Raspberry Pi\* 3)
 207
 208 1. Install Docker\*:
 209
 210   ```bash
 211   sudo apt-get install -y docker.io
 212   ```
 213
 214 2. Add a current user to `docker` group:
 215
 216   ```bash
 217   sudo usermod -a -G docker $USER
 218   ```
 219
 220   Log out and log in for this to take effect.
 221
 222 3. Create a directory named `ie_cross_armhf` and add a text file named `Dockerfile`
 223 with the following content:
 224
 225   ```docker
 226   FROM debian:stretch
 227
 228   USER root
 229
 230   RUN dpkg --add-architecture armhf && \
 231       apt-get update && \
 232       apt-get install -y --no-install-recommends \
 233       build-essential \
 234       crossbuild-essential-armhf \
 235       git \
 236       wget \
 237       libusb-1.0-0-dev:armhf \
 238       libgtk-3-dev:armhf \
 239       libavcodec-dev:armhf \
 240       libavformat-dev:armhf \
 241       libswscale-dev:armhf \
 242       libgstreamer1.0-dev:armhf \
 243       libgstreamer-plugins-base1.0-dev:armhf \
 244       libpython3-dev:armhf \
 245       python3-pip
 246
 247   RUN wget https://www.cmake.org/files/v3.14/cmake-3.14.3.tar.gz && \
 248       tar xf cmake-3.14.3.tar.gz && \
 249       (cd cmake-3.14.3 && ./bootstrap --parallel=$(nproc --all) && make --jobs=$(nproc --all) && make install) && \
 250       rm -rf cmake-3.14.3 cmake-3.14.3.tar.gz
 251   ```
 252
 253   It uses the Debian\* Stretch (Debian 9) OS for compilation because it is a base of the Raspbian\* Stretch.
 254
 255 4. Build a Docker\* image:
 256
 257   ```bash
 258   docker image build -t ie_cross_armhf ie_cross_armhf
 259   ```
 260
 261 5. Run Docker\* container with mounted source code folder from host:
 262
 263   ```bash
 264   docker run -it -v /absolute/path/to/openvino:/openvino ie_cross_armhf /bin/bash
 265   ```
 266
 267 6. While in the container:
 268
 269     1. Go to the cloned `openvino` repository:
 270
 271       ```bash
 272       cd openvino
 273       ```
 274
 275     2. Create a build folder:
 276
 277       ```bash
 278       mkdir build && cd build
 279       ```
 280
 281     3. Build the Inference Engine:
 282
 283       ```bash
 284       cmake -DCMAKE_BUILD_TYPE=Release \
 285           -DCMAKE_TOOLCHAIN_FILE="../cmake/arm.toolchain.cmake" \
 286           -DTHREADS_PTHREAD_ARG="-pthread" \
 287           -DENABLE_SSE42=OFF \
 288           -DTHREADING=SEQ \
 289           -DENABLE_GNA=OFF .. && make --jobs=$(nproc --all)
 290       ```
 291
 292 7. Press **Ctrl+D** to exit from Docker. You can find the resulting binaries
 293    in the `openvino/bin/armv7l/` directory and the OpenCV*
 294    installation in the `openvino/inference-engine/temp`.
 295
 296 >**NOTE**: Native applications that link to cross-compiled Inference Engine
 297 library require an extra compilation flag `-march=armv7-a`.
 298
 299 ### Additional Build Options
 300
 301 You can use the following additional build options:
 302
 303 - Required versions of OpenCV packages are downloaded automatically by the
 304   CMake-based script. If you want to use the automatically downloaded packages
 305   but you already have installed OpenCV packages configured in your environment,
 306   you may need to clean the `OpenCV_DIR` environment variable before running
 307   the `cmake` command; otherwise they won't be downloaded and the build may
 308   fail if incompatible versions were installed.
 309
 310 - If the CMake-based build script cannot find and download the OpenCV package
 311   that is supported on your platform, or if you want to use a custom build of
 312   the OpenCV library, see: [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
 313   for details.
 314
 315 - To build Python API wrapper, install `libpython3-dev:armhf` and `python3-pip`
 316   packages using `apt-get`; then install `numpy` and `cython` python modules
 317   via `pip3`, adding the following options:
 318    ```sh
 319    -DENABLE_PYTHON=ON \
 320    -DPYTHON_EXECUTABLE=/usr/bin/python3.5 \
 321    -DPYTHON_LIBRARY=/usr/lib/arm-linux-gnueabihf/libpython3.5m.so \
 322    -DPYTHON_INCLUDE_DIR=/usr/include/python3.5
 323    ```
 324
 325 - nGraph-specific compilation options:
 326   `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
 327   `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
 328
 329 ## Build on Windows* Systems
 330
 331 The software was validated on:
 332 - Microsoft\* Windows\* 10 (64-bit) with Visual Studio 2017 and Intel® C++
 333   Compiler 2018 Update 3
 334
 335 ### Software Requirements
 336 - [CMake]\*3.11 or higher
 337 - Microsoft\* Visual Studio 2017, 2019 or [Intel® C++ Compiler] 18.0
 338 - (Optional) Intel® Graphics Driver for Windows* (26.20) [driver package].
 339 - Python 3.5 or higher for Inference Engine Python API wrapper
 340
 341 ### Build Steps
 342
 343 1. Clone submodules:
 344     ```sh
 345     git submodule update --init --recursive
 346     ```
 347 2. By default, the build enables the Inference Engine GPU plugin to infer models
 348    on your Intel® Processor Graphics. This requires you to [download and install
 349    the Intel® Graphics Driver for Windows (26.20) [driver package] before
 350    running the build. If you don't want to use the GPU plugin, use the
 351    `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
 352    Intel® Graphics Driver.
 353 3. Create build directory:
 354     ```sh
 355     mkdir build
 356     ```
 357 4. In the `build` directory, run `cmake` to fetch project dependencies and
 358    generate a Visual Studio solution.
 359
 360    For Microsoft\* Visual Studio 2017:
 361 ```sh
 362 cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_BUILD_TYPE=Release ..
 363 ```
 364
 365    For Microsoft\* Visual Studio 2019:
 366 ```sh
 367 cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release ..
 368 ```
 369
 370    For Intel® C++ Compiler 18:
 371 ```sh
 372 cmake -G "Visual Studio 15 2017 Win64" -T "Intel C++ Compiler 18.0" ^
 373     -DCMAKE_BUILD_TYPE=Release ^
 374     -DICCLIB="C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib" ..
 375 ```
 376
 377 5. Build generated solution in Visual Studio or run
 378    `cmake --build . --config Release` to build from the command line.
 379
 380 6. Before running the samples, add paths to the TBB and OpenCV binaries used for
 381    the build to the `%PATH%` environment variable. By default, TBB binaries are
 382    downloaded by the CMake-based script to the `<openvino_repo>/inference-engine/temp/tbb/bin`
 383    folder, OpenCV binaries to the `<openvino_repo>/inference-engine/temp/opencv_4.3.0/opencv/bin`
 384    folder.
 385
 386 ### Additional Build Options
 387
 388 - Internal JIT GEMM implementation is used by default.
 389
 390 - To switch to OpenBLAS GEMM implementation, use the `-DGEMM=OPENBLAS` CMake
 391   option and specify path to OpenBLAS using the `-DBLAS_INCLUDE_DIRS=<OPENBLAS_DIR>\include`
 392   and `-DBLAS_LIBRARIES=<OPENBLAS_DIR>\lib\libopenblas.dll.a` options. Download
 393   a prebuilt OpenBLAS\* package via the [OpenBLAS] link. mingw64* runtime
 394   dependencies can be downloaded via the [mingw64\* runtime dependencies] link.
 395
 396 - To switch to the optimized MKL-ML\* GEMM implementation, use the
 397   `-DGEMM=MKL` and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to
 398   unpacked MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be
 399   downloaded from the Intel&reg; [MKL-DNN repository for Windows].
 400
 401 - Threading Building Blocks (TBB) is used by default. To build the Inference
 402   Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
 403
 404 - Required versions of TBB and OpenCV packages are downloaded automatically by
 405   the CMake-based script. If you want to use the automatically-downloaded
 406   packages but you already have installed TBB or OpenCV packages configured in
 407   your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
 408   environment variables before running the `cmake` command; otherwise they won't
 409   be downloaded and the build may fail if incompatible versions were installed.
 410
 411 - If the CMake-based build script can not find and download the OpenCV package
 412   that is supported on your platform, or if you want to use a custom build of
 413   the OpenCV library, refer to the [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
 414   section for details.
 415
 416 - To switch off/on the CPU and GPU plugins, use the `cmake` options
 417   `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
 418
 419 - To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
 420   specify an exact Python version, use the following options:
 421    ```sh
 422    -DPYTHON_EXECUTABLE="C:\Program Files\Python37\python.exe" ^
 423    -DPYTHON_LIBRARY="C:\Program Files\Python37\libs\python37.lib" ^
 424    -DPYTHON_INCLUDE_DIR="C:\Program Files\Python37\include"
 425    ```
 426
 427 - nGraph-specific compilation options:
 428   `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
 429   `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
 430
 431 ### Building Inference Engine with Ninja* Build System
 432
 433 ```sh
 434 call "C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\bin\ipsxe-comp-vars.bat" intel64 vs2017
 435 set CXX=icl
 436 set CC=icl
 437 :: clean TBBROOT value set by ipsxe-comp-vars.bat, required TBB package will be downloaded by openvino cmake script
 438 set TBBROOT=
 439 cmake -G Ninja -Wno-dev -DCMAKE_BUILD_TYPE=Release ..
 440 cmake --build . --config Release
 441 ```
 442
 443 ## Build on macOS* Systems
 444
 445 > **NOTE**: The current version of the OpenVINO™ toolkit for macOS* supports
 446 inference on Intel CPUs only.
 447
 448 The software was validated on:
 449 - macOS\* 10.14, 64-bit
 450
 451 ### Software Requirements
 452
 453 - [CMake]\* 3.11 or higher
 454 - Clang\* compiler from Xcode\* 10.1 or higher
 455 - Python\* 3.5 or higher for the Inference Engine Python API wrapper
 456
 457 ### Build Steps
 458
 459 1. Clone submodules:
 460     ```sh
 461     cd openvino
 462     git submodule update --init --recursive
 463     ```
 464 2. Install build dependencies using the `install_dependencies.sh` script in the
 465    project root folder:
 466    ```sh
 467    chmod +x install_dependencies.sh
 468    ```
 469    ```sh
 470    ./install_dependencies.sh
 471    ```
 472 3. Create a build folder:
 473 ```sh
 474   mkdir build
 475 ```
 476 4. Inference Engine uses a CMake-based build system. In the created `build`
 477    directory, run `cmake` to fetch project dependencies and create Unix makefiles,
 478    then run `make` to build the project:
 479 ```sh
 480   cmake -DCMAKE_BUILD_TYPE=Release ..
 481   make --jobs=$(nproc --all)
 482 ```
 483 ### Additional Build Options
 484
 485 You can use the following additional build options:
 486
 487 - Internal JIT GEMM implementation is used by default.
 488
 489 - To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL` and
 490   `-DMKLROOT=<path_to_MKL>` cmake options to specify a path to unpacked MKL-ML
 491   with the `include` and `lib` folders. MKL-ML\* [package for Mac] can be downloaded
 492   [here](https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_mac_2019.0.5.20190502.tgz)
 493
 494 - Threading Building Blocks (TBB) is used by default. To build the Inference
 495   Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
 496
 497 - Required versions of TBB and OpenCV packages are downloaded automatically by
 498   the CMake-based script. If you want to use the automatically downloaded
 499   packages but you already have installed TBB or OpenCV packages configured in
 500   your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
 501   environment variables before running the `cmake` command, otherwise they won't
 502   be downloaded and the build may fail if incompatible versions were installed.
 503
 504 - If the CMake-based build script can not find and download the OpenCV package
 505   that is supported on your platform, or if you want to use a custom build of
 506   the OpenCV library, refer to the
 507   [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
 508   section for details.
 509
 510 - To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
 511   specify an exact Python version, use the following options:
 512 ```sh
 513   -DPYTHON_EXECUTABLE=/Library/Frameworks/Python.framework/Versions/3.7/bin/python3.7 \
 514   -DPYTHON_LIBRARY=/Library/Frameworks/Python.framework/Versions/3.7/lib/libpython3.7m.dylib \
 515   -DPYTHON_INCLUDE_DIR=/Library/Frameworks/Python.framework/Versions/3.7/include/python3.7m
 516 ```
 517
 518 - nGraph-specific compilation options:
 519   `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
 520   `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
 521
 522 ## Build on Android* Systems
 523
 524 This section describes how to build Inference Engine for Android x86 (64-bit) operating systems.
 525
 526 ### Software Requirements
 527
 528 - [CMake]\* 3.11 or higher
 529 - Android NDK (this guide has been validated with r20 release)
 530
 531 ### Build Steps
 532
 533 1. Download and unpack Android NDK: https://developer.android.com/ndk/downloads. Let's assume that `~/Downloads` is used as a working folder.
 534   ```sh
 535   cd ~/Downloads
 536   wget https://dl.google.com/android/repository/android-ndk-r20-linux-x86_64.zip
 537
 538   unzip android-ndk-r20-linux-x86_64.zip
 539   mv android-ndk-r20 android-ndk
 540   ```
 541
 542 2. Clone submodules
 543   ```sh
 544   cd openvino
 545   git submodule update --init --recursive
 546   ```
 547
 548 3. Create a build folder:
 549   ```sh
 550     mkdir build
 551   ```
 552
 553 4. Change working directory to `build` and run `cmake` to create makefiles. Then run `make`.
 554   ```sh
 555   cd build
 556
 557   cmake .. \
 558     -DCMAKE_TOOLCHAIN_FILE=~/Downloads/android-ndk/build/cmake/android.toolchain.cmake \
 559     -DANDROID_ABI=x86_64 \
 560     -DANDROID_PLATFORM=21 \
 561     -DANDROID_STL=c++_shared \
 562     -DENABLE_OPENCV=OFF
 563
 564   make --jobs=$(nproc --all)
 565   ```
 566
 567   * `ANDROID_ABI` specifies target architecture (`x86_64`)
 568   * `ANDROID_PLATFORM` - Android API version
 569   * `ANDROID_STL` specifies that shared C++ runtime is used. Copy `~/Downloads/android-ndk/sources/cxx-stl/llvm-libc++/libs/x86_64/libc++_shared.so` from Android NDK along with built binaries
 570
 571
 572 ## Use Custom OpenCV Builds for Inference Engine
 573
 574 > **NOTE**: The recommended and tested version of OpenCV is 4.4.0.
 575
 576 Required versions of OpenCV packages are downloaded automatically during the
 577 building Inference Engine library. If the build script can not find and download
 578 the OpenCV package that is supported on your platform, you can use one of the
 579 following options:
 580
 581 * Download the most suitable version from the list of available pre-build
 582   packages from [https://download.01.org/opencv/2020/openvinotoolkit] from the
 583   `<release_version>/inference_engine` directory.
 584
 585 * Use a system-provided OpenCV package (e.g with running the
 586   `apt install libopencv-dev` command). The following modules must be enabled:
 587   `imgcodecs`, `videoio`, `highgui`.
 588
 589 * Get the OpenCV package using a package manager: pip, conda, conan etc. The
 590   package must have the development components included (header files and CMake
 591   scripts).
 592
 593 * Build OpenCV from source using the [build instructions](https://docs.opencv.org/master/df/d65/tutorial_table_of_content_introduction.html) on the OpenCV site.
 594
 595 After you got the built OpenCV library, perform the following preparation steps
 596 before running the Inference Engine build:
 597
 598 1. Set the `OpenCV_DIR` environment variable to the directory where the
 599    `OpenCVConfig.cmake` file of you custom OpenCV build is located.
 600 2. Disable the package automatic downloading with using the `-DENABLE_OPENCV=OFF`
 601    option for CMake-based build script for Inference Engine.
 602
 603 ## Add Inference Engine to Your Project
 604
 605 For CMake projects, set the `InferenceEngine_DIR` environment variable:
 606
 607 ```sh
 608 export InferenceEngine_DIR=/path/to/openvino/build/
 609 ```
 610
 611 Then you can find Inference Engine by `find_package`:
 612
 613 ```cmake
 614 find_package(InferenceEngine)
 615 include_directories(${InferenceEngine_INCLUDE_DIRS})
 616 target_link_libraries(${PROJECT_NAME} ${InferenceEngine_LIBRARIES} dl)
 617 ```
 618
 619 ## (Optional) Additional Installation Steps for the Intel® Movidius™ Neural Compute Stick and Neural Compute Stick 2
 620
 621 > **NOTE**: These steps are only required if you want to perform inference on
 622 Intel® Movidius™ Neural Compute Stick or the Intel® Neural Compute Stick 2 using
 623 the Inference Engine MYRIAD Plugin. See also [Intel® Neural Compute Stick 2 Get Started].
 624
 625 ### For Linux, Raspbian\* Stretch OS
 626
 627 1. Add the current Linux user to the `users` group; you will need to log out and
 628    log in for it to take effect:
 629 ```sh
 630 sudo usermod -a -G users "$(whoami)"
 631 ```
 632
 633 2. To perform inference on Intel® Movidius™ Neural Compute Stick and Intel®
 634    Neural Compute Stick 2, install the USB rules as follows:
 635 ```sh
 636 cat <<EOF > 97-myriad-usbboot.rules
 637 SUBSYSTEM=="usb", ATTRS{idProduct}=="2150", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
 638 SUBSYSTEM=="usb", ATTRS{idProduct}=="2485", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
 639 SUBSYSTEM=="usb", ATTRS{idProduct}=="f63b", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
 640 EOF
 641 ```
 642 ```sh
 643 sudo cp 97-myriad-usbboot.rules /etc/udev/rules.d/
 644 ```
 645 ```sh
 646 sudo udevadm control --reload-rules
 647 ```
 648 ```sh
 649 sudo udevadm trigger
 650 ```
 651 ```sh
 652 sudo ldconfig
 653 ```
 654 ```sh
 655 rm 97-myriad-usbboot.rules
 656 ```
 657
 658 ## Next Steps
 659
 660 Congratulations, you have built the Inference Engine. To get started with the
 661 OpenVINO™, proceed to the Get Started guides:
 662
 663 * [Get Started with Deep Learning Deployment Toolkit on Linux*](get-started-linux.md)
 664
 665 ## Notice
 666
 667 To enable some additional nGraph features and use your custom nGraph library with the OpenVINO™ binary package,
 668 make sure the following:
 669 - nGraph library was built with the same version which is used in the Inference Engine.
 670 - nGraph library and the Inference Engine were built with the same compilers. Otherwise you might face application binary interface (ABI) problems.
 671
 672 To prepare your custom nGraph library for distribution, which includes collecting all headers, copy
 673 binaries, and so on, use the `install` CMake target.
 674 This target collects all dependencies, prepares the nGraph package and copies it to a separate directory.
 675
 676 ## Additional Resources
 677
 678 * [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
 679 * [Introduction to Intel® Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
 680 * [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html)
 681 * [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
 682 * [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
 683
 684 ---
 685 \* Other names and brands may be claimed as the property of others.
 686
 687
 688 [Intel® Distribution of OpenVINO™]:https://software.intel.com/en-us/openvino-toolkit
 689 [CMake]:https://cmake.org/download/
 690 [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]:https://github.com/intel/compute-runtime/releases/tag/19.41.14441
 691 [MKL-DNN repository]:https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_lnx_2019.0.5.20190502.tgz
 692 [MKL-DNN repository for Windows]:(https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_win_2019.0.5.20190502.zip)
 693 [OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download
 694 [mingw64\* runtime dependencies]:https://sourceforge.net/projects/openblas/files/v0.2.14/mingw64_dll.zip/download
 695 [https://download.01.org/opencv/2020/openvinotoolkit]:https://download.01.org/opencv/2020/openvinotoolkit
 696 [build instructions]:https://docs.opencv.org/master/df/d65/tutorial_table_of_content_introduction.html
 697 [driver package]:https://downloadcenter.intel.com/download/29335/Intel-Graphics-Windows-10-DCH-Drivers
 698 [Intel® Neural Compute Stick 2 Get Started]:https://software.intel.com/en-us/neural-compute-stick/get-started
 699 [Intel® C++ Compiler]:https://software.intel.com/en-us/intel-parallel-studio-xe
 700 [OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download