+++ /dev/null
-# How to Contribute
-We welcome community contributions to the OpenVINO™ repository.
-If you have an idea how to improve the product, please share it
-with us doing the following steps:
-
-* Make sure you can build the product and run all tests and samples with your patch
-* In case of a larger feature, provide relevant unit tests and one or more sample
-* Submit a pull request at https://github.com/openvinotoolkit/openvino/pulls
-
-## OpenVINO™ Coding Style Guide
-We basically use the Google style (https://google.github.io/styleguide/cppguide.html) with some exceptions:
-* 4 spaces instead of 2 spaces for indentations
-* Limitation of 160 symbols for the line length
-* Exceptions are allowed
-* Using namespace are allowed in cpp and prohibited in headers
-* Underscore symbol before member in classes/structures
-* thisStyleForFunctions()
-* theSameStyleForVariables
+++ /dev/null
-# Contribute to Documentation
-
-If you want to contribute to a project documentation and make it better, your help is very welcome.
-This guide puts together the guidelines to help you figure out how you can offer your feedback and contribute to the documentation.
-
-## Contribute in Multiple ways
-
-There are multiple ways to help improve our documentation:
-* [Log an issue](https://jira.devtools.intel.com/projects/CVS/issues): Enter an issue for the OpenVINO™ documentation component for minor issues such as typos.
-* Make a suggestion: Send your documentation suggestion to the mailing list.
-* Contribute via GitHub: Submit pull requests in the [GitHub](https://github.com/openvinotoolkit/openvino/tree/master/docs) documentation repository.
-
-## Contribute via GitHub
-
-Use the following steps to contribute in the OpenVINO™ Toolkit documentation
-
-### Use Documentation Guidelines
-The documentation for our project is written using Markdown. Use our [guidelines](./docs/documentation_guidelines.md) and best practices to write consistent, readable documentation:
-
-* **[Authoring Guidelines](./docs/documentation_guidelines.md#authoring-guidelines)**
-* **[Structure Guidelines](./docs/documentation_guidelines.md#structure-guidelines)**
-* **[Formatting Guidelines](./docs/documentation_guidelines.md#structure-guidelines)**
-* **[Graphics Guidelines](./docs/documentation_guidelines.md#graphics-guidelines)**
-
-### Add New Document to the Documentation
-> **NOTE**: Please check if that information can be added to existing documents instead of creating a new one.
-
-1. Fork the [OpenVINO™ Toolkit](https://github.com/openvinotoolkit/openvino) repository.
-2. Create a new branch.
-3. Create a new markdown file in an appropriate folder.
- > **REQUIRED**: The document title must contain a document label in a form: `{#openvino_docs_<name>}`. For example: `Deep Learning Network Intermediate Representation and Operation Sets in OpenVINO™ {#openvino_docs_MO_DG_IR_and_opsets}`.
-4. Add your file to the documentation structure. Open the documentation structure file [docs/doxygen/ie_docs.xml](./docs/doxygen/ie_docs.xml) and add your file path to the appropriate section.
-5. Commit changes to your branch.
-6. Create a pull request.
-7. Once the pull request is created, automatic checks are started. All checks must pass to continue.
-8. Discuss, review, and update your contributions.
-9. Get merged once the maintainer approves.
-
-### Edit Existing Document
-1. Fork the [OpenVINO™ Toolkit](https://github.com/openvinotoolkit/openvino) repository.
-2. Create a new branch.
-3. Edit the documentation markdown file and commit changes to the branch.
-4. Create a pull request.
-5. Once the pull request is created, automatic checks are started. All checks must pass to continue.
-6. Discuss, review, and update your contributions.
-7. Get merged once the maintainer approves.
-
-### Delete Document from the Documentation
-1. Fork the [OpenVINO™ Toolkit](https://github.com/openvinotoolkit/openvino) repository.
-2. Create a new branch.
-3. Remove the documentation file.
-4. Remove your file from the documentation structure. Open the documentation structure file [docs/doxygen/ie_docs.xml](./docs/doxygen/ie_docs.xml) and remove all occurences of your file path.
-5. Remove all references to that file from other documents or replace with links to alternatives topics (if any).
-6. Commit changes to your branch.
-7. Create a pull request.
-8. Once the pull request is created, automatic checks are started. All checks must pass to continue.
-9. Discuss, review, and update your contributions.
-10. Get merged once the maintainer approves.
This toolkit allows developers to deploy pre-trained deep learning models
through a high-level C++ Inference Engine API integrated with application logic.
-This open source version includes two components: namely [Model Optimizer] and
-[Inference Engine], as well as CPU, GPU and heterogeneous plugins to accelerate
-deep learning inferencing on Intel® CPUs and Intel® Processor Graphics.
+This open source version includes several components: namely [Model Optimizer], [ngraph] and
+[Inference Engine], as well as CPU, GPU, MYRIAD, multi device and heterogeneous plugins to accelerate deep learning inferencing on Intel® CPUs and Intel® Processor Graphics.
It supports pre-trained models from the [Open Model Zoo], along with 100+ open
source and public models in popular formats such as Caffe\*, TensorFlow\*,
MXNet\* and ONNX\*.
## Repository components:
* [Inference Engine]
+* [ngraph]
* [Model Optimizer]
## License
By contributing to the project, you agree to the license and copyright terms therein
and release your contribution under these terms.
-## Documentation
+## Resources:
+* Docs: https://docs.openvinotoolkit.org/
+* Wiki: https://github.com/openvinotoolkit/openvino/wiki
+* Issue tracking: https://github.com/openvinotoolkit/openvino/issues
+* Additional OpenVINO modules: https://github.com/openvinotoolkit/openvino_contrib
+* [HomePage](https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit.html)
* [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
-* [OpenVINO™ Inference Engine Build Instructions](build-instruction.md)
-* [Get Started with Deep Learning Deployment Toolkit on Linux](get-started-linux.md)\*
-* [Introduction to Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
-* [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
-* [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
-* [Get Started with DockerHub CI for OpenVINO™ toolkit](https://github.com/openvinotoolkit/docker_ci/blob/master/README.md)
-
-## How to Contribute
-See [CONTRIBUTING](./CONTRIBUTING.md) for contribution to the code.
-See [CONTRIBUTING_DOCS](./CONTRIBUTING_DOCS.md) for contribution to the documentation.
-Thank you!
## Support
Please report questions, issues and suggestions using:
[Inference Engine]:https://software.intel.com/en-us/articles/OpenVINO-InferEngine
[Model Optimizer]:https://software.intel.com/en-us/articles/OpenVINO-ModelOptimizer
[tag on StackOverflow]:https://stackoverflow.com/search?q=%23openvino
+[ngraph]:https://docs.openvinotoolkit.org/latest/openvino_docs_nGraph_DG_DevGuide.html
\ No newline at end of file
+++ /dev/null
-# Security Policy
-
-## Report a Vulnerability
-
-Please report security issues or vulnerabilities to the [Intel® Security Center].
-
-For more information on how Intel® works to resolve security issues, see
-[Vulnerability Handling Guidelines].
-
-[Intel® Security Center]:https://www.intel.com/security
-
-[Vulnerability Handling Guidelines]:https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html
+++ /dev/null
-# Build OpenVINO™ Inference Engine
-
-## Contents
-
-- [Introduction](#introduction)
-- [Build on Linux\* Systems](#build-on-linux-systems)
- - [Software Requirements](#software-requirements)
- - [Build Steps](#build-steps)
- - [Additional Build Options](#additional-build-options)
-- [Build for Raspbian* Stretch OS](#build-for-raspbian-stretch-os)
- - [Hardware Requirements](#hardware-requirements)
- - [Native Compilation](#native-compilation)
- - [Cross Compilation Using Docker\*](#cross-compilation-using-docker)
- - [Additional Build Options](#additional-build-options-1)
-- [Build on Windows* Systems](#build-on-windows-systems)
- - [Software Requirements](#software-requirements-1)
- - [Build Steps](#build-steps-1)
- - [Additional Build Options](#additional-build-options-2)
- - [Building Inference Engine with Ninja* Build System](#building-inference-engine-with-ninja-build-system)
-- [Build on macOS\* Systems](#build-on-macos-systems)
- - [Software Requirements](#software-requirements-2)
- - [Build Steps](#build-steps-2)
- - [Additional Build Options](#additional-build-options-3)
-- [Build on Android\* Systems](#build-on-android-systems)
- - [Software Requirements](#software-requirements-3)
- - [Build Steps](#build-steps-3)
-- [Use Custom OpenCV Builds for Inference Engine](#use-custom-opencv-builds-for-inference-engine)
-- [Add Inference Engine to Your Project](#add-inference-engine-to-your-project)
-- [(Optional) Additional Installation Steps for the Intel® Neural Compute Stick 2](#optional-additional-installation-steps-for-the-intel-movidius-neural-compute-stick-and-neural-compute-stick-2)
- - [For Linux, Raspbian Stretch* OS](#for-linux-raspbian-stretch-os)
-- [Next Steps](#next-steps)
-- [Additional Resources](#additional-resources)
-
-## Introduction
-
-The Inference Engine can infer models in different formats with various input
-and output formats.
-
-The open source version of Inference Engine includes the following plugins:
-
-| PLUGIN | DEVICE TYPES |
-| ---------------------| -------------|
-| CPU plugin | Intel® Xeon® with Intel® AVX2 and AVX512, Intel® Core™ Processors with Intel® AVX2, Intel® Atom® Processors with Intel® SSE |
-| GPU plugin | Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics |
-| 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 |
-| MYRIAD plugin | Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X |
-| Heterogeneous plugin | Heterogeneous plugin enables computing for inference on one network on several Intel® devices. |
-
-## Build on Linux\* Systems
-
-The software was validated on:
-- Ubuntu\* 18.04 (64-bit) with default GCC\* 7.5.0
-- Ubuntu\* 20.04 (64-bit) with default GCC\* 9.3.0
-- CentOS\* 7.6 (64-bit) with default GCC\* 4.8.5
-
-### Software Requirements
-- [CMake]\* 3.13 or higher
-- GCC\* 4.8 or higher to build the Inference Engine
-- Python 3.6 or higher for Inference Engine Python API wrapper
-- (Optional) [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441].
-> **NOTE**: Building samples and demos from the Intel® Distribution of OpenVINO™ toolkit package requires CMake\* 3.10 or higher.
-
-### Build Steps
-1. Clone submodules:
- ```sh
- cd openvino
- git submodule update --init --recursive
- ```
-2. Install build dependencies using the `install_build_dependencies.sh` script in the
- project root folder.
- ```sh
- chmod +x install_build_dependencies.sh
- ```
- ```sh
- ./install_build_dependencies.sh
- ```
-3. By default, the build enables the Inference Engine GPU plugin to infer models
- on your Intel® Processor Graphics. This requires you to
- [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]
- before running the build. If you don't want to use the GPU plugin, use the
- `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
- Intel® Graphics Compute Runtime for OpenCL™ Driver.
-4. Create a build folder:
-```sh
- mkdir build && cd build
-```
-5. Inference Engine uses a CMake-based build system. In the created `build`
- directory, run `cmake` to fetch project dependencies and create Unix
- makefiles, then run `make` to build the project:
-```sh
- cmake -DCMAKE_BUILD_TYPE=Release ..
- make --jobs=$(nproc --all)
-```
-
-### Additional Build Options
-
-You can use the following additional build options:
-
-- The default build uses an internal JIT GEMM implementation.
-
-- To switch to an OpenBLAS\* implementation, use the `GEMM=OPENBLAS` option with
- `BLAS_INCLUDE_DIRS` and `BLAS_LIBRARIES` CMake options to specify a path to the
- OpenBLAS headers and library. For example, the following options on CentOS\*:
- `-DGEMM=OPENBLAS -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DBLAS_LIBRARIES=/usr/lib64/libopenblas.so.0`.
-
-- To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL`
- and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to unpacked
- MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be downloaded
- from the Intel® [MKL-DNN repository].
-
-- Threading Building Blocks (TBB) is used by default. To build the Inference
- Engine with OpenMP\* threading, set the `-DTHREADING=OMP` option.
-
-- Required versions of TBB and OpenCV packages are downloaded automatically by
- the CMake-based script. If you want to use the automatically downloaded
- packages but you already have installed TBB or OpenCV packages configured in
- your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
- environment variables before running the `cmake` command, otherwise they
- will not be downloaded and the build may fail if incompatible versions were
- installed.
-
-- If the CMake-based build script can not find and download the OpenCV package
- that is supported on your platform, or if you want to use a custom build of
- the OpenCV library, refer to the
- [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
- section for details.
-
-- To build the Python API wrapper:
- 1. Install all additional packages listed in the
- `/inference-engine/ie_bridges/python/requirements.txt` file:
- ```sh
- pip install -r requirements.txt
- ```
- 2. Use the `-DENABLE_PYTHON=ON` option. To specify an exact Python version, use the following
- options:
- ```
- -DPYTHON_EXECUTABLE=`which python3.7` \
- -DPYTHON_LIBRARY=/usr/lib/x86_64-linux-gnu/libpython3.7m.so \
- -DPYTHON_INCLUDE_DIR=/usr/include/python3.7
- ```
-
-- To switch the CPU and GPU plugins off/on, use the `cmake` options
- `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
-
-- nGraph-specific compilation options:
- `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
- `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
-
-## Build for Raspbian Stretch* OS
-
-> **NOTE**: Only the MYRIAD plugin is supported.
-
-### Hardware Requirements
-* 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`).
-
- > **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.
-
-You can compile the Inference Engine for Raspberry Pi\* in one of the two ways:
-* [Native Compilation](#native-compilation), which is the simplest way, but time-consuming
-* [Cross Compilation Using Docker*](#cross-compilation-using-docker), which is the recommended way
-
-### Native Compilation
-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.
-
-1. Install dependencies:
-
- ```bash
- sudo apt-get update
- sudo apt-get install -y git cmake libusb-1.0-0-dev
- ```
-
-2. Go to the cloned `openvino` repository:
-
- ```bash
- cd openvino
- ```
-
-3. Initialize submodules:
-
- ```bash
- git submodule update --init --recursive
- ```
-
-4. Create a build folder:
-
- ```bash
- mkdir build && cd build
- ```
-
-5. Build the Inference Engine:
-
- ```bash
- cmake -DCMAKE_BUILD_TYPE=Release \
- -DENABLE_SSE42=OFF \
- -DTHREADING=SEQ \
- -DENABLE_GNA=OFF .. && make
- ```
-
-### Cross Compilation Using Docker*
-
- This compilation was tested on the following configuration:
-
- * Host: Ubuntu\* 18.04 (64-bit, Intel® Core™ i7-6700K CPU @ 4.00GHz × 8)
- * Target: Raspbian\* Stretch (32-bit, ARMv7, Raspberry Pi\* 3)
-
-1. Install Docker\*:
-
- ```bash
- sudo apt-get install -y docker.io
- ```
-
-2. Add a current user to `docker` group:
-
- ```bash
- sudo usermod -a -G docker $USER
- ```
-
- Log out and log in for this to take effect.
-
-3. Create a directory named `ie_cross_armhf` and add a text file named `Dockerfile`
-with the following content:
-
- ```docker
- FROM debian:stretch
-
- USER root
-
- RUN dpkg --add-architecture armhf && \
- apt-get update && \
- apt-get install -y --no-install-recommends \
- build-essential \
- crossbuild-essential-armhf \
- git \
- wget \
- libusb-1.0-0-dev:armhf \
- libgtk-3-dev:armhf \
- libavcodec-dev:armhf \
- libavformat-dev:armhf \
- libswscale-dev:armhf \
- libgstreamer1.0-dev:armhf \
- libgstreamer-plugins-base1.0-dev:armhf \
- libpython3-dev:armhf \
- python3-pip \
- python-minimal \
- python-argparse
-
- RUN wget https://www.cmake.org/files/v3.14/cmake-3.14.3.tar.gz && \
- tar xf cmake-3.14.3.tar.gz && \
- (cd cmake-3.14.3 && ./bootstrap --parallel=$(nproc --all) && make --jobs=$(nproc --all) && make install) && \
- rm -rf cmake-3.14.3 cmake-3.14.3.tar.gz
- ```
-
- It uses the Debian\* Stretch (Debian 9) OS for compilation because it is a base of the Raspbian\* Stretch.
-
-4. Build a Docker\* image:
-
- ```bash
- docker image build -t ie_cross_armhf ie_cross_armhf
- ```
-
-5. Run Docker\* container with mounted source code folder from host:
-
- ```bash
- docker run -it -v /absolute/path/to/openvino:/openvino ie_cross_armhf /bin/bash
- ```
-
-6. While in the container:
-
- 1. Go to the cloned `openvino` repository:
-
- ```bash
- cd openvino
- ```
-
- 2. Create a build folder:
-
- ```bash
- mkdir build && cd build
- ```
-
- 3. Build the Inference Engine:
-
- ```bash
- cmake -DCMAKE_BUILD_TYPE=Release \
- -DCMAKE_TOOLCHAIN_FILE="../cmake/arm.toolchain.cmake" \
- -DTHREADS_PTHREAD_ARG="-pthread" \
- -DENABLE_SSE42=OFF \
- -DTHREADING=SEQ \
- -DENABLE_GNA=OFF .. && make --jobs=$(nproc --all)
- ```
-
-7. Press **Ctrl+D** to exit from Docker. You can find the resulting binaries
- in the `openvino/bin/armv7l/` directory and the OpenCV*
- installation in the `openvino/inference-engine/temp`.
-
->**NOTE**: Native applications that link to cross-compiled Inference Engine
-library require an extra compilation flag `-march=armv7-a`.
-
-### Additional Build Options
-
-You can use the following additional build options:
-
-- Required versions of OpenCV packages are downloaded automatically by the
- CMake-based script. If you want to use the automatically downloaded packages
- but you already have installed OpenCV packages configured in your environment,
- you may need to clean the `OpenCV_DIR` environment variable before running
- the `cmake` command; otherwise they won't be downloaded and the build may
- fail if incompatible versions were installed.
-
-- If the CMake-based build script cannot find and download the OpenCV package
- that is supported on your platform, or if you want to use a custom build of
- the OpenCV library, see: [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
- for details.
-
-- To build Python API wrapper, install `libpython3-dev:armhf` and `python3-pip`
- packages using `apt-get`; then install `numpy` and `cython` python modules
- via `pip3`, adding the following options:
- ```sh
- -DENABLE_PYTHON=ON \
- -DPYTHON_EXECUTABLE=/usr/bin/python3.5 \
- -DPYTHON_LIBRARY=/usr/lib/arm-linux-gnueabihf/libpython3.5m.so \
- -DPYTHON_INCLUDE_DIR=/usr/include/python3.5
- ```
-
-- nGraph-specific compilation options:
- `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
- `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
-
-## Build on Windows* Systems
-
-The software was validated on:
-- Microsoft\* Windows\* 10 (64-bit) with Visual Studio 2019
-
-### Software Requirements
-- [CMake]\*3.13 or higher
-- Microsoft\* Visual Studio 2017, 2019
-- (Optional) Intel® Graphics Driver for Windows* (26.20) [driver package].
-- Python 3.6 or higher for Inference Engine Python API wrapper
-> **NOTE**: Building samples and demos from the Intel® Distribution of OpenVINO™ toolkit package requires CMake\* 3.10 or higher.
-
-### Build Steps
-
-1. Clone submodules:
- ```sh
- git submodule update --init --recursive
- ```
-2. By default, the build enables the Inference Engine GPU plugin to infer models
- on your Intel® Processor Graphics. This requires you to [download and install
- the Intel® Graphics Driver for Windows (26.20) [driver package] before
- running the build. If you don't want to use the GPU plugin, use the
- `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
- Intel® Graphics Driver.
-3. Create build directory:
- ```sh
- mkdir build
- ```
-4. In the `build` directory, run `cmake` to fetch project dependencies and
- generate a Visual Studio solution.
-
- For Microsoft\* Visual Studio 2017:
-```sh
-cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_BUILD_TYPE=Release ..
-```
-
- For Microsoft\* Visual Studio 2019:
-```sh
-cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release ..
-```
-
-5. Build generated solution in Visual Studio or run
- `cmake --build . --config Release` to build from the command line.
-
-6. Before running the samples, add paths to the TBB and OpenCV binaries used for
- the build to the `%PATH%` environment variable. By default, TBB binaries are
- downloaded by the CMake-based script to the `<openvino_repo>/inference-engine/temp/tbb/bin`
- folder, OpenCV binaries to the `<openvino_repo>/inference-engine/temp/opencv_4.5.0/opencv/bin`
- folder.
-
-### Additional Build Options
-
-- Internal JIT GEMM implementation is used by default.
-
-- To switch to OpenBLAS GEMM implementation, use the `-DGEMM=OPENBLAS` CMake
- option and specify path to OpenBLAS using the `-DBLAS_INCLUDE_DIRS=<OPENBLAS_DIR>\include`
- and `-DBLAS_LIBRARIES=<OPENBLAS_DIR>\lib\libopenblas.dll.a` options. Download
- a prebuilt OpenBLAS\* package via the [OpenBLAS] link. mingw64* runtime
- dependencies can be downloaded via the [mingw64\* runtime dependencies] link.
-
-- To switch to the optimized MKL-ML\* GEMM implementation, use the
- `-DGEMM=MKL` and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to
- unpacked MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be
- downloaded from the Intel® [MKL-DNN repository for Windows].
-
-- Threading Building Blocks (TBB) is used by default. To build the Inference
- Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
-
-- Required versions of TBB and OpenCV packages are downloaded automatically by
- the CMake-based script. If you want to use the automatically-downloaded
- packages but you already have installed TBB or OpenCV packages configured in
- your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
- environment variables before running the `cmake` command; otherwise they won't
- be downloaded and the build may fail if incompatible versions were installed.
-
-- If the CMake-based build script can not find and download the OpenCV package
- that is supported on your platform, or if you want to use a custom build of
- the OpenCV library, refer to the [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
- section for details.
-
-- To switch off/on the CPU and GPU plugins, use the `cmake` options
- `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
-
-- To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
- specify an exact Python version, use the following options:
- ```sh
- -DPYTHON_EXECUTABLE="C:\Program Files\Python37\python.exe" ^
- -DPYTHON_LIBRARY="C:\Program Files\Python37\libs\python37.lib" ^
- -DPYTHON_INCLUDE_DIR="C:\Program Files\Python37\include"
- ```
-
-- nGraph-specific compilation options:
- `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
- `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
-
-### Building Inference Engine with Ninja* Build System
-
-```sh
-call "C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\bin\ipsxe-comp-vars.bat" intel64 vs2017
-set CXX=icl
-set CC=icl
-:: clean TBBROOT value set by ipsxe-comp-vars.bat, required TBB package will be downloaded by openvino cmake script
-set TBBROOT=
-cmake -G Ninja -Wno-dev -DCMAKE_BUILD_TYPE=Release ..
-cmake --build . --config Release
-```
-
-## Build on macOS* Systems
-
-> **NOTE**: The current version of the OpenVINO™ toolkit for macOS* supports
-inference on Intel CPUs only.
-
-The software was validated on:
-- macOS\* 10.15, 64-bit
-
-### Software Requirements
-
-- [CMake]\* 3.13 or higher
-- Clang\* compiler from Xcode\* 10.1 or higher
-- Python\* 3.6 or higher for the Inference Engine Python API wrapper
-> **NOTE**: Building samples and demos from the Intel® Distribution of OpenVINO™ toolkit package requires CMake\* 3.10 or higher.
-
-### Build Steps
-
-1. Clone submodules:
- ```sh
- cd openvino
- git submodule update --init --recursive
- ```
-2. Create a build folder:
-```sh
- mkdir build && cd build
-```
-3. Inference Engine uses a CMake-based build system. In the created `build`
- directory, run `cmake` to fetch project dependencies and create Unix makefiles,
- then run `make` to build the project:
-```sh
- cmake -DCMAKE_BUILD_TYPE=Release ..
- make --jobs=$(nproc --all)
-```
-### Additional Build Options
-
-You can use the following additional build options:
-
-- Internal JIT GEMM implementation is used by default.
-
-- To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL` and
- `-DMKLROOT=<path_to_MKL>` cmake options to specify a path to unpacked MKL-ML
- with the `include` and `lib` folders. MKL-ML\* [package for Mac] can be downloaded
- [here](https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_mac_2019.0.5.20190502.tgz)
-
-- Threading Building Blocks (TBB) is used by default. To build the Inference
- Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
-
-- Required versions of TBB and OpenCV packages are downloaded automatically by
- the CMake-based script. If you want to use the automatically downloaded
- packages but you already have installed TBB or OpenCV packages configured in
- your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
- environment variables before running the `cmake` command, otherwise they won't
- be downloaded and the build may fail if incompatible versions were installed.
-
-- If the CMake-based build script can not find and download the OpenCV package
- that is supported on your platform, or if you want to use a custom build of
- the OpenCV library, refer to the
- [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
- section for details.
-
-- To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
- specify an exact Python version, use the following options:
- - If you installed Python through Homebrew*, set the following flags:
- ```sh
- -DPYTHON_EXECUTABLE=/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/bin/python3.7m \
- -DPYTHON_LIBRARY=/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/libpython3.7m.dylib \
- -DPYTHON_INCLUDE_DIR=/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/include/python3.7m
- ```
- - If you installed Python another way, you can use the following commands to find where the `dylib` and `include_dir` are located, respectively:
- ```sh
- find /usr/ -name 'libpython*m.dylib'
- find /usr/ -type d -name python3.7m
- ```
-- nGraph-specific compilation options:
- `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
- `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
-
-## Build on Android* Systems
-
-This section describes how to build Inference Engine for Android x86 (64-bit) operating systems.
-
-### Software Requirements
-
-- [CMake]\* 3.13 or higher
-- Android NDK (this guide has been validated with r20 release)
-> **NOTE**: Building samples and demos from the Intel® Distribution of OpenVINO™ toolkit package requires CMake\* 3.10 or higher.
-
-### Build Steps
-
-1. Download and unpack Android NDK: https://developer.android.com/ndk/downloads. Let's assume that `~/Downloads` is used as a working folder.
- ```sh
- cd ~/Downloads
- wget https://dl.google.com/android/repository/android-ndk-r20-linux-x86_64.zip
-
- unzip android-ndk-r20-linux-x86_64.zip
- mv android-ndk-r20 android-ndk
- ```
-
-2. Clone submodules
- ```sh
- cd openvino
- git submodule update --init --recursive
- ```
-
-3. Create a build folder:
- ```sh
- mkdir build
- ```
-
-4. Change working directory to `build` and run `cmake` to create makefiles. Then run `make`.
- ```sh
- cd build
-
- cmake .. \
- -DCMAKE_TOOLCHAIN_FILE=~/Downloads/android-ndk/build/cmake/android.toolchain.cmake \
- -DANDROID_ABI=x86_64 \
- -DANDROID_PLATFORM=21 \
- -DANDROID_STL=c++_shared \
- -DENABLE_OPENCV=OFF
-
- make --jobs=$(nproc --all)
- ```
-
- * `ANDROID_ABI` specifies target architecture (`x86_64`)
- * `ANDROID_PLATFORM` - Android API version
- * `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
-
-
-## Use Custom OpenCV Builds for Inference Engine
-
-> **NOTE**: The recommended and tested version of OpenCV is 4.4.0.
-
-Required versions of OpenCV packages are downloaded automatically during the
-building Inference Engine library. If the build script can not find and download
-the OpenCV package that is supported on your platform, you can use one of the
-following options:
-
-* Download the most suitable version from the list of available pre-build
- packages from [https://download.01.org/opencv/2020/openvinotoolkit] from the
- `<release_version>/inference_engine` directory.
-
-* Use a system-provided OpenCV package (e.g with running the
- `apt install libopencv-dev` command). The following modules must be enabled:
- `imgcodecs`, `videoio`, `highgui`.
-
-* Get the OpenCV package using a package manager: pip, conda, conan etc. The
- package must have the development components included (header files and CMake
- scripts).
-
-* 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.
-
-After you got the built OpenCV library, perform the following preparation steps
-before running the Inference Engine build:
-
-1. Set the `OpenCV_DIR` environment variable to the directory where the
- `OpenCVConfig.cmake` file of you custom OpenCV build is located.
-2. Disable the package automatic downloading with using the `-DENABLE_OPENCV=OFF`
- option for CMake-based build script for Inference Engine.
-
-## Add Inference Engine to Your Project
-
-For CMake projects, set the `InferenceEngine_DIR` environment variable:
-
-```sh
-export InferenceEngine_DIR=/path/to/openvino/build/
-```
-
-Then you can find Inference Engine by `find_package`:
-
-```cmake
-find_package(InferenceEngine)
-include_directories(${InferenceEngine_INCLUDE_DIRS})
-target_link_libraries(${PROJECT_NAME} ${InferenceEngine_LIBRARIES} dl)
-```
-
-## (Optional) Additional Installation Steps for the Intel® Neural Compute Stick 2
-
-> **NOTE**: These steps are only required if you want to perform inference on the
-Intel® Neural Compute Stick 2 using the Inference Engine MYRIAD Plugin. See also
-[Intel® Neural Compute Stick 2 Get Started].
-
-### For Linux, Raspbian\* Stretch OS
-
-1. Add the current Linux user to the `users` group; you will need to log out and
- log in for it to take effect:
-```sh
-sudo usermod -a -G users "$(whoami)"
-```
-
-2. To perform inference on Intel® Neural Compute Stick 2, install the USB rules
-as follows:
-```sh
-cat <<EOF > 97-myriad-usbboot.rules
-SUBSYSTEM=="usb", ATTRS{idProduct}=="2485", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
-SUBSYSTEM=="usb", ATTRS{idProduct}=="f63b", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
-EOF
-```
-```sh
-sudo cp 97-myriad-usbboot.rules /etc/udev/rules.d/
-```
-```sh
-sudo udevadm control --reload-rules
-```
-```sh
-sudo udevadm trigger
-```
-```sh
-sudo ldconfig
-```
-```sh
-rm 97-myriad-usbboot.rules
-```
-
-## Next Steps
-
-Congratulations, you have built the Inference Engine. To get started with the
-OpenVINO™, proceed to the Get Started guides:
-
-* [Get Started with Deep Learning Deployment Toolkit on Linux*](get-started-linux.md)
-
-## Notice
-
-To enable some additional nGraph features and use your custom nGraph library with the OpenVINO™ binary package,
-make sure the following:
-- nGraph library was built with the same version which is used in the Inference Engine.
-- nGraph library and the Inference Engine were built with the same compilers. Otherwise you might face application binary interface (ABI) problems.
-
-To prepare your custom nGraph library for distribution, which includes collecting all headers, copy
-binaries, and so on, use the `install` CMake target.
-This target collects all dependencies, prepares the nGraph package and copies it to a separate directory.
-
-## Additional Resources
-
-* [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
-* [Introduction to Intel® Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
-* [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html)
-* [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
-* [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
-
----
-\* Other names and brands may be claimed as the property of others.
-
-
-[Intel® Distribution of OpenVINO™]:https://software.intel.com/en-us/openvino-toolkit
-[CMake]:https://cmake.org/download/
-[Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]:https://github.com/intel/compute-runtime/releases/tag/19.41.14441
-[MKL-DNN repository]:https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_lnx_2019.0.5.20190502.tgz
-[MKL-DNN repository for Windows]:(https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_win_2019.0.5.20190502.zip)
-[OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download
-[mingw64\* runtime dependencies]:https://sourceforge.net/projects/openblas/files/v0.2.14/mingw64_dll.zip/download
-[https://download.01.org/opencv/2020/openvinotoolkit]:https://download.01.org/opencv/2020/openvinotoolkit
-[build instructions]:https://docs.opencv.org/master/df/d65/tutorial_table_of_content_introduction.html
-[driver package]:https://downloadcenter.intel.com/download/29335/Intel-Graphics-Windows-10-DCH-Drivers
-[Intel® Neural Compute Stick 2 Get Started]:https://software.intel.com/en-us/neural-compute-stick/get-started
-[OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download
+++ /dev/null
-# Regression tests howto {#openvino_docs_HOWTO_add_regression_test_vpu}
-
-## Purpose
-
-This document contains instructions for correctly modifying a set of regression tests.
-
-## Common
-
-Regression tests for Myriad and HDDL plugins are on the path:
-`inference-engine/tests/functional/vpu/regression_tests/`
-
-The tests are divided into 4 groups:
-* Classification
-* Detection
-* Raw-results
-* Compilation
-* VPU hetero
-
-Testing framework – [Google Test](https://github.com/google/googletest/).
-Each group contains [parameterized](https://github.com/google/googletest/blob/master/googletest/docs/advanced.md) tests. The main idea is that to add a new test, you only need to add a new parameter. Except for scenarios different from the generalized case.
-
-## Classsification and Detection tests
-
-These groups contains two cases:
-
-* For generalized scenario (` VpuNoClassificationRegression, VpuNoDetectionRegression`)
-* For specific scenario (` VpuNoClassificationRegressionSpecific, VpuNoDetectionRegressionSpecific`)
-
-### Generalized scenario
-
-If You want test new parameter(batch, precision, model and etc.) then You need to edit the existing initialization of parameterized tests or create a new one.
-Example of initialization of parameterized tests:
-
-``` c++
-INSTANTIATE_TEST_CASE_P(
- VPURegTestWithResources_nightly,
- VpuNoClassificationRegression,
- Combine(ValuesIn(VpuTestParamsContainer::testingPlugin()),
- Values(Precision::FP16),
- Values(1), // batches
- Values(true), //IsHwAdaptiveMode
- Values(false), //DoReshape
- Values(3, 5, 7), //Resources
- Values(false), //IsIgnoreStatistic
- Values(ClassificationSrcParam{ModelName::GoogleNetV1, SourceImages::kCat3, 0.01, Regression::EMean::eValues})),
- VpuNoClassificationRegression::getTestCaseName);
-```
-
-### Specific scenario
-
-If You need a test to perform some actions that are not provided in the generalized scenario, then add a specific test case. As with the generalized scenario You can change parameters for these tests.
-Example of specific test case:
-
-``` c++
-TEST_P(VpuNoClassificationRegressionSpecific, onAlexNetWithNetworkConfig) {
- DISABLE_ON_WINDOWS_IF(HDDL_PLUGIN);
- DISABLE_IF(do_reshape_);
-
- if (!hw_adaptive_mode_) {
- config_[VPU_CONFIG_KEY(NETWORK_CONFIG)] = "data=data,scale=1";
- }
-
- assertThat().classificationResultsForInferRequestAPI()
- .on(SourceImages::kDog2)
- .withInputPrecision(in_precision_)
- .times(batch_)
- .withBatch(batch_)
- .onModel(ModelName::AlexNet)
- .setMean(Regression::EMean::eImage)
- .onFP16()
- .withTopK(1)
- .withPluginConfig(config_)
- .equalToReferenceWithDelta(0.04);
-}
-```
-
-## Raw-results tests
-
-There is no generalized scenario and recommendations are the same as for specific test cases for Classification/Detection groups.
-
-## Compilation tests
-
-The tests are in the `vpu_classification_regression.cpp` file and contain only one scenario ` VpuNoRegressionWithCompilation `. To add a new test just update parameters just as in generalized scenario of Classification/Detection test groups.
+++ /dev/null
-# Fuzzing howto {#openvino_docs_HOWTO_fuzzing_HOWTO}
-
-## Intended Audience
-
-This document is for a developer who wants to contribute fuzz tests.
-
-## Purpose
-
-This document walks you through creating your first fuzzer, running it and evaluating its quality.
-
-## Prerequisites
-
-- Linux OS or Mac OS.
-
-- [American Fuzzy Loop](http://lcamtuf.coredump.cx/afl/) if building with GCC.
-
-## Steps
-
-1. Create a fuzz test in the existing project at `./tests/fuzz`. Fuzz test must
- follow `<test name>-fuzzer.cc` naming scheme and implement a
- `LLVMFuzzerTestOneInput` entry point.
-
-``` bash
-cat << EOF > ./tests/fuzz/test_name-fuzzer.cc
-#include <stdint.h>
-#include <cstdlib>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- // put your fuzzing code here and use data+size as input.
- return 0; // always return 0
-}
-EOF
-```
-
-2. Implement test logic under `LLVMFuzzerTestOneInput`.
-
-See example fuzz test at `tests/fuzz/read_network-fuzzer.cc`.
-
-3. Build fuzz tests with `-DENABLE_FUZZING=ON` flag for cmake.
-
-``` bash
- mkdir -p build && \
- (cd build && \
- CXX=afl-g++ CC=afl-gcc cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_FUZZING=ON -DENABLE_TESTS=ON .. && \
- make fuzz --jobs=$(getconf _NPROCESSORS_ONLN))
-```
-
-4. Prepare sample inputs for your fuzz test to teach fuzzer engine on input
- structure
-
-``` bash
-(cd bin/intel64/Debug && \
-mkdir test_name-corpus && \
-echo sample input > test_name-corpus/in1.txt)
-```
-
-5. Evaluate fuzz test with `afl-fuzz` fuzzing engine
-
-Run fuzz test:
-
-``` bash
-(cd bin/intel64/Debug && \
-afl-fuzz -i test_name-corpus -o test_name-out -- ./test_name-fuzzer @@
-```
-
-While fuzz test is running it prints out statistics. Besides just crashes `uniq
-crashes` and hangs `uniq hangs` you should care about fuzz test quality:
-
-- Fuzz test should be fast - speed of execution `exec speed` should be at least
- 100 exec/s. Speed less than 20 exec/s is not acceptable.
-
-- Fuzz test should be able to explore new code paths `map coverage` and
- `findings in depth`. Confirm it is increasing while fuzz test is running.
-
-6. Reproduce fuzz test findings
-
-All issues found by fuzz test are stored as a file in output folder specified
-earlier via `-o` afl-fuzz option. To reproduce an issue run fuzz test executable
-with an issue file as an argument.
-
-## Summary
-
-We have created a simple fuzz test, run it and asses its results.
-
-## Extension
-
-Try run parallel fuzzing with the help of
-[afl-utils](https://gitlab.com/rc0r/afl-utils).
-
-## Tips or FAQs
-
-GCC 7 in Ubuntu 18.04 LTS has a
-[defect](https://bugs.launchpad.net/ubuntu/+source/afl/+bug/1774816). Upgrade
-GCC 7 for AFL to work. GCC version `Ubuntu 7.3.0-27ubuntu1~18.04` works OK.
+++ /dev/null
-# Inference Engine development configuration document {#openvino_docs_Inference_Engine_Development_Procedure_CONTRIBUTING}
-
-To create MakeFiles use following process or run build-after-clone.sh script located in the root
-folder if you use Ubuntu 18.04.
-To create Visual Studio project run create_vs_proj_x64.cmd from scripts folder.
-
-## Setting up the environment for development
-
-1. Update/init submodules bu running
-```bash
-git submodule init
-git submodule update --recursive
-```
-2. Install [Git LFS](https://git-lfs.github.com) extension. It's required to download models
- from the [repo](https://gitlab-icv.inn.intel.com/inference-engine/models-ir)
- Below is step by step guide to install Git LFS.
-
- 2.1 Linux
- ```bash
- wget https://github.com/git-lfs/git-lfs/releases/download/v2.3.4/git-lfs-linux-amd64-2.3.4.tar.gz
- tar xf git-lfs-linux-amd64-2.3.4.tar.gz
- cd git-lfs-2.3.4
- sudo PREFIX=/usr/ ./install.sh
- git config --global http.sslverify false
- ```
- 2.1 Windows
- 2.1.1 Download
- [Git LFS](https://github.com/git-lfs/git-lfs/releases/download/v2.3.4/git-lfs-windows-2.3.4.exe)
- and install it.
- 2.1.2 Run console command
- ```bash
- git config --global http.sslverify false
- ```
- > **NOTE**: HTTPS protocol is used to download files by Git LFS. You either have to
- > disable HTTPS proxy for local resources like GitLab server gitlab-icv.inn.intel.com by setting
- > `no_proxy=localhost,gitlab-icv.inn.intel.com` or switch to `http://proxy-chain.intel.com:911` proxy server,
- > because it disables proxy for local servers automatically.
-
-3. Use Cmake to fetch project dependencies and create Unix makefiles
- ```bash
- mkdir build
- cd build
- ```
- There are number of options which turn on some components during builds and initiate downloading of the models
-
- `-DENABLE_TESTS=ON` - to build functional and behavior tests
- this will copy necessary dependencies to ./temp folder, or to ENV.DL_SDK_TEMP folder if environment variable set
- `-DENABLE_FUNCTIONAL_TESTS=ON` - to build functional tests
- `-DCMAKE_BUILD_TYPE=Debug/Release` - to point debug or release configuration. Missing this option will generate something between
- Release and Debug and you might be surprised by certain aspects of the compiled binaries
- `-DENABLE_PRIVATE_MODELS=ON` - copy private models from https://gitlab-icv.inn.intel.com/inference-engine-models/private-ir with restricted access
-
- The full command line enough for development is following:
- ```bash
- cmake -DENABLE_TESTS=ON -DENABLE_FUNCTIONAL_TESTS=ON -DCMAKE_BUILD_TYPE=Debug ..
- ```
-
- The full command line enough for validation before push to the server
- ```bash
- cmake -DENABLE_TESTS=ON -DENABLE_FUNCTIONAL_TESTS=ON -DCMAKE_BUILD_TYPE=Release ..
- ```
-
-4. Build project and tests:
-```bash
-make -j16
-```
-
-5. To build documentation:
- a. Install doxygen and graphviz:
- ```bash
- apt-get install doxygen && apt-get install graphviz && apt-get install texlive
- ```
- b. Go to the documentation build directory:
- ```bash
- cd to scripts/build_documentation
- ```
- c. Run the `build_docs.sh` script:
- * To build the documentation set that includes documentation from the current branch of the
- `inference-engine` repo and specific branches of the `openvino-documentation`, `models` and
- `model-optimizer-tensorflow` repos, specify three branches as parameters:
- ```sh
- ./build_docs.sh ovinodoc:<OPENVINO_BRANCH> models:<MODELS_BRANCH> mo:<MO_BRANCH>
- ```
- * To build the documentation set that includes only documentation from the current branch of the
- `inference-engine` repo, run the script with no parameters:
- ```sh
- ./build_docs.sh
- ```
-
- > **NOTE**: You should run the script either with specifying all three parameters or without any parameters.
-
- d. Find the generated documentation in the `root_directory/doc` directory
-
- > **NOTE**: If you make any changes in the documentation source files, it is recommended to cleanup the
- > documentation build directory and continue with step 3:
- >```sh
- > cd scripts/build_documentation
- > ./clean.sh
- > ```
-
- > **NOTE**: The scripts for building documentation use SSH for cloning repositories. Please, make sure that
- you have
- > added your SSH key to git-lab. For more information about it, please visit the
- > [instructions page](https://gitlab-icv.inn.intel.com/help/ssh/README.md)
-
-
-## Compilers supported and verified
-
-All others may be compatible but Inference Engine does not guarantee that.
-
-* Linux : gcc(5.4)\*, clang(3.9)
-* MacOS : gcc(5.4), clang(3.9)\*
-* Windows: MSVC(14), ICC(17.0)\*
- \* - is target compiler for platform and used for public external drops
-
-## TeamCity CI
-
-TeamCity CI server is available
-[here](https://teamcity01-ir.devtools.intel.com/project.html?projectId=DeepLearningSdk_DeepLearningSdk_InferenceEngine)
-
-To get access to the server, go to
-[AGS](https://ags.intel.com/identityiq/lcm/requestAccess.jsf) and search "DevTools -- INDE xOS - Project Developer".
-
-
-## Troubleshooting steps
-
-1. **Issue**: Build of the "mkldnn" project failed on Windows with "Error MSB6003 The specified task
- executable "cmd.exe" could not be run. The working directory "\mkl\tools" does not exist".
- **Solution**: open InferenceEngine.sln -> goto "mkldnn" project
- Properties -> Configuration Properties -> Intel Performance Libraries -> Use Intel MKL -> choose "No"
\ No newline at end of file
+++ /dev/null
-# Inference Engine coverage report build {#openvino_docs_Inference_Engine_Development_Procedure_COVERAGE}
-
-The coverage report is generated using Lcov tool and based on profile data generated by GCC.
-The generated reports are in HTML form and located in `<dldt_build>/coverage`. The reports are generated for the following components:
-
-1. `inference_engine` - main Inference Engine library
-1. `inference_engine_legacy` - legacy Inference Engine library
-1. `inference_engine_ir_reader` - Inference Engine IR reader library
-1. `low_precision_transformations` - library with Low Precision transformations.
-1. `inference_engine_transformations` - Ngraph-based transformation for Inference Engine.
-1. `preprocessing` - Inference Engine G-API based preprocessing plugin.
-1. Inference Engine open-sources plugins:
- - `hetero_plugin` - Heterogeneous plugin.
- - `multi_device` - Multi device plugin.
- - `cldnn_engine` - GPU plugin.
- - `mkldnn_plugin` - CPU plugin.
- - `gna_plugin` - GNA plugin.
-
-## Build with profiling data support
-
-To build coverage report, compile DLDT with an additional CMake option `-DENABLE_COVERAGE=ON`:
-
-```bash
-$ cmake -DENABLE_COVERAGE=ON .
-```
-
-And build DLDT as usual.
-
-## Generate coverage report
-
-In order to generate coverage reports, first of all, the tests must be run. Depending on how many tests are run, the better covegare percentage can be achieved. E.g. for `inference_engine` component, `InferenceEngineUnitTests`, `ieUnitTests`, `ieFuncTests` must be run as well as plugin tests.
-
-```bash
-$ ctest -V -L IE
-```
-
-After sufficient number of tests are executed, the coverage numbers can be calculated. In order to do this, run:
-
-```bash
-$ make ie_coverage
-```
-
-The following tree of reports are generated:
-
-```bash
-$ find coverage/ -maxdepth 2 -name index.html
-coverage/hetero_plugin/index.html
-coverage/inference_engine/index.html
-coverage/inference_engine_ir_reader/index.html
-coverage/inference_engine_legacy/index.html
-coverage/low_precision_transformations/index.html
-coverage/mkldnn_plugin/index.html
-coverage/multi_device/index.html
-coverage/preprocessing/index.html
-coverage/inference_engine_transformations/index.html
-coverage/gna_plugin/index.html
-coverage/cldnn_engine/index.html
-```
\ No newline at end of file
+++ /dev/null
-# Development Flow for Adding New Changes to the Inference Engine {#openvino_docs_Inference_Engine_Development_Procedure_IE_Dev_Procedure}
-
-## Develop Your Feature
-1. Create a branch based on the latest version of a target branch (`master` or `release`).
- Use the following branch naming:
- * *feature/<userid>/<name>* - stands for temporary work area for creating a feature or performing bug fixes
- * *scout/<name>* - is used for shared development if several developers work on one feature
- **IMPORTANT**: Do not use long branch name, because it may lead to failed CI jobs on Windows. Name length must be less 40 characters.
-2. Commit changes on your branch and push it to remote.
-
-
-## Create a Merge Request
-1. Go to the [GitLab\\\* merge request page](https://gitlab-icv.inn.intel.com/inference-engine/dldt/merge_requests)
-
-2. Create a merge request by pressing on **New Merge Request** or **Create merge request**. Choose an `inference-engine` project from the drop-down list.
- <br/>
- ![mr1]
-
- a. Fill the **Title** and **Description** fields with meaningful information. This information should be enough to understand the changes you made:
-
- Use this template for the **Title** field. If you did not finish your work on current bug/feature, add `[WIP]` to the beginning of the title:
- ```
- [Domain] Small description for merge request (can use first string from the commit message)
- ```
- Use domain from the following list:
- * [IE COMMON] - if a solution impacts common Inference Engine functionality
- * [IE EXTENSION]
- * [IE PYTHON]
- * [IE SAMPLES]
- * [IE TESTS]
- * [IE DOCS]
- * [IE MKLDNN]
- * [IE GNA]
- * [IE CLDNN]
- * [IE MYRIAD]
- * [IE HDDL]
- * [IE HETERO]
-
- You can use several domains in one commit message. For example: [COMMON][MKLDNN] <Text>
-
- Use this template to fill **Description** field:
- ```
- <Multi-line description of the commit>
-
- JIRA: <url_to_jira_ticket>
- CI: <url_to_validation_result_in_CI>
- <url_to_passed_rebuilt_changes_in_CI>
- ```
-
- b. Add **Milestone** and **Labels** to the MR if it is possible.
-
- c. If your work is finished, assign the MR to a reviewer. If it is in progress, assign the MR to yourself (`[WIP]` case).
-
- Example of an [MR](https://gitlab-icv.inn.intel.com/inference-engine/inference-engine/merge_requests/2512):
- <br/>
- ![mr_example1]
-
- >**NOTE**: When creating an MR, please remember that even a person who does not know what this feature/merge request stands for >should be able to understand the reasons why this feature/change was created.
-
-3. Change the history of your branch:
-
- a. Squash commits on your branch into one (you can have some number of logically separated commits if it is needed). Use the following template for commit message:
-
- ```
- [Domain] Small description of commit
-
- Multiline commit additional comments:
- * additional comment 1
- * additional comment 2
-
- JIRA: CVS-xxxx
- ```
-
-
- Example of the commit message:
- <br/>
- ![commit_message]
-
- >**NOTE**: if there is no JIRA ticket for your task, you can leave this line empty.
-
- b. Rebase your branch to the latest version of the target branch. The difference between the last validated version of the branch must be no more than one day.
-
- c. Push your updates to the remote branch. You can use force push if needed, for example, when you rebase your branch to latest version of the target branch.
-
-4. Add required people as reviewers of the MR. Please list appropriate GitLab accounts in the discussion section of the MR.
-
-5. Run validation build (refer to the ["Run tests under CI"](#run-tests-under-ci))
-
-6. When review is complited and you have one or several **Thumb up** in your MR:
- a. Make sure that all comments are fixed and all discussions are resolved
- b. Run validation build again, make sure that all tests are passed, and update link to CI in the MR description
- c. Create cherry-picked MR if needed (refer to the ["Create a Cherry-Picked MR (Optional)"](#create-a-cherry-picked-mr-(optional))) and validate it by CI.
-
- Example of an [MR](https://gitlab-icv.inn.intel.com/inference-engine/inference-engine/merge_requests/2111):
- <br/>
- ![mr_example]
-
-7. Reassign the MR to the someone from integration managers.
-
-8. An integration manager will close or merge your MR.
- <br/>
- ![mr2]
-
-## Create a Cherry-Picked MR (Optional)
-1. If you need to merge your changes in both target branch (`release` and `master`), create new merge request to another target branch containing cherry-pick with approved commit.
- Follow the rules above to create the MR (sections 1 and 2 in (**Create a Merge Request**)[#create-a-merge-request]), but add line "\*\*cherry-picked from MR: !xxxx**" to the MR description and assign the MR to someine from the integration managers.
-
-2. Run validation build (refer to "Run tests under CI" section).
-
-3. Assign the MR to an integration manager.
-
-4. The integration manager will merge or close your MR.
-
-## Run Tests under CI
-1. Go to the CI page: [TeamCity](https://teamcity01-ir.devtools.intel.com/project.html?projectId=DeepLearningSdk_DeepLearningSdk_InferenceEngineUnifiedRepo)
-
-2. Click the **Run Engineering Validation** (if you want to merge your changes into `master` branch) or **Run Engineering Validation for XXXX RX Release branch** (if you want merge changes into `release` branch):
- <br/>
- ![run_engineering]
-
-3. Select your branch in the top left corner:
- <br/>
- ![select_branch]
-
-4. If you have not committed anything to your branch for the past several days, you might not see your branch in the list. In this case, you can choose it in the properties of **Run Engineering Validation** task (if you want merge changes into `master` branch) or **Run Release Validation** task (if you want merge changes into `release` branch). Click on **Run** button. On the third tab, choose your branch and click the **Run Build**:
- <br/>
- ![run_tests]
-
-5. Click on an arrow right after **1 queued**. On a new dialog window, click on a build number. In this case, it is 1825:
- <br/>
- ![view_results]
-
- You will see the current status of tests:
- <br/>
- ![analyze_results]
-
-6. Make sure that all tests are passed.
- If some test failed, see build log in TeamCity: choose failed build in dependencies, click on the result and go to **Build log** tab.
- * If it looks like an infrastructure issue (for example, an absence of a software or a network issue), restart the build.
- * If you think that your changes could not break the test, rebase your branch on latest version of `master` restart build. If the build failed again, explore build history: an incorrect code might have merged into the target branch before branching that is not fixed till current moment.
- * If you have an issue with code style, run code style checks `<IE_repo>/scripts/run_code_check.sh` locally to analyze the reason of failed CI jobs (see the picture below) and restart them if required:
- <br/>
- ![code_style_artifacts]
-
- Commit your changes.
-
- **Please add link to restarted build in MR description**
-
-## Merge Changes to a Target Branch (master or release branches)
-1. The `master` and `release` branches are protected. Only integration managers can merge to these branches
-
-2. Assigned integration manager checks if all the requirements are met. If so, they can merge MR with the **Merge** button or manually.
-
-3. An integration manager removes a branch if an MR author has set an appropriate flag for this MR in GitLab GUI.
-
-[mr_example]: img/mr_example.png
-[mr_example1]: img/mr_example1.png
-[commit_message]: img/commit_message.png
-[code_style_artifacts]: img/code_style_artifacts.png
-[select_branch]: img/select_branch.png
-[run_engineering]: img/run_engineering.png
-[run_tests]: img/run_tests.png
-[view_results]: img/view_results.png
-[analyze_results]: img/analyze_results.png
-[mr1]: img/mr1.png
-[mr2]: img/mr2.png
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:5a5a0ce07310382c6265bef5942e676f29114981e56f6329b901055c42c8dff5
-size 293945
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:67e1a33ba22ef58c7dbb78e4ef07b1f0d83ef926e6cd63e55731e056b06964d6
-size 218208
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:a88aa0d55207761ab3b5a9ebbe9a8610d55623a12e867438616461fd79e13082
-size 10739
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:3e9b00393f8d26dbaa89f82c653bc03214305255369eee4ac0b7843f4fa18ab6
-size 107057
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:8e08347a27464c90038fd1f3737154e1af4c9546dfff46bfe7fcbb720758c08d
-size 43082
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:fab30e9b33189493bb4e129aaf672d9240a812295fb8c359070bbaceb03d7c9b
-size 40107
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:163daea84811ab00fcda952915302a6a6ad712b53a27cc3e49c04146bfda698b
-size 43281
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:ed9e74765a8eba71b3df08b9f2d5a5acf2e605db73fd3c1c20bc28334408bdf4
-size 31140
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:a2285feece5b7ae18d690cd58c3282eafd1913279a4dd86afdaa18a50af9a890
-size 180101
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:7f0b0ce84951be0da5326d28540f57ad561f49c3c0abaad6eff33a7189bc808d
-size 102331
+++ /dev/null
-version https://git-lfs.github.com/spec/v1
-oid sha256:3ff4bcfde5169f74ac09220ea04022fff3d12607a67805e10b13876768651d8d
-size 47649
+++ /dev/null
-# Documentation Guidelines
-
-## Authoring Guidelines
-
-We want our documentation to be easy to read and understand. This section describes guidelines for writing documentation that is clear, concise, confident, and courteous.
-
-For details on organizing content and how we use Markdown, refer to [Structure and Formatting](#structure-and-formatting-guidelines).
-
-### Use Simple English
-
-* **Be brief.** Use short sentences and paragraphs. Stick to the principle of one main idea per sentence, plus one additional point if needed. Each paragraph should address one main idea. Remember the basic structure of a paragraph: Introduction, body, and conclusion.
-* **Use simple words.** Use simple words to increase reader comprehension and reduce ambiguity. Follow our tips for making good word choices:
- * **Avoid jargon:** Write for your audience, using everyday language where possible, and technical terms where appropriate. Avoid clichés, idioms, and metaphors.
- * **Be consistent:** Use one term for each concept or action and use it consistently.
- * **Avoid “fancy” words and phrases:** If there is a simpler word or phrase, use it.
-
-### Make Content Scannable
-
-Organize your content to make it scannable for the reader, which helps them find what they need quickly, and to understand the information more efficiently.
-
-* **Put the most important content first.** Make sure your introduction clearly communicates what the reader can find on the page. Present the point of the document first, and organize supporting information towards the end of the page.
-* **Write scannable headings.** Expect readers of documentation to skim and scan the content, and to leave if they don’t find what they need quickly. Good headings add organization to your content and help the reader to find and understand content more effectively. Follow our guidelines for writing effective Headings.
-* **Write great link text.** Great link text tells the reader what they can expect when they click on a link. It also helps make the page more scannable. Follow our guidelines for writing Link text.
-
-### Use Strong Verbs
-
-* **Passive verbs make writing stuffy and formal**. Use strong verbs to get to the point and avoid unnecessary words and phrases.
-* **Commands**, also called imperatives, are the fastest and most direct way of giving someone instructions.
-* **Use simple present tense** instead of future tense for most text. Search for the words “will” or “shall” to find future tense instances. Future tense is acceptable for conditional statements, such as in a caution or a warning.
-
-### Parallelism
-
-Parallelism refers to the practice of using similar patterns of grammar, and sometimes length, to coordinate words, phrases, and clauses.
-Use parallel construction in lists. The table below shows some unparallel structures and how they can be made parallel with a little rewording.
-
-| Parallel (do) | Unparallel (don’t) |
-|-------------------------|---------------------------|
-| 1. Mount the panel. | 1. Mount the panel. |
-| 2. Install the battery. | 2. Battery installation. |
-| 3. Wire the keypad. | 3. Wiring the keypad. |
-
-## Structure Guidelines
-
-Content should be organized to support scanning. Consistent organization, formatting, and writing style helps readers quickly find what they need and to understand the content more effectively. This section describes our organization.
-
-### Website Structure
-The documentation website is organized this way:
-
-1. **Getting Started**: installation guides, prerequisites, how to set working environment
-2. **How To-s**: videos and guides, for some reason not included in **Guides** section
-3. **Guides**: developer guides for all OpenVINO Toolkit components
-4. **Resources**: samples, demos, pre-trained models and tools (Accuracy Checker, Post-Training Optimization etc)
-5. **Performance Information**: benchmark tests information, ways to improve Performance
-6. **API References**: in-built wiki with class structures
-
-### Page Structures
-Each page in the documentation should follow the basic format of:
-
-* **Overview**: 1-2 sentences describing what this page shows and why it matters
-* **Prerequisites**: Describe any pre-work necessary to the content (if appropriate)
-* **Content**
-* **Next steps**: List links to next steps (if appropriate)
-* **Related topics**: List links to related content (if appropriate)
-
-## Formatting Guidelines
-We apply the formatting using Markdown.
-
-### Inline Text Formatting
-Use our quick reference for the most commonly used inline text elements:
-
-| Element | Markdown Examples | Notes |
-|--------------- |---------------------| -------- |
-| Notes | `> **NOTE**: text` | The space between `>` and `**NOTE**` is required |
-| Code elements (variables, methods, classes) | ``` `text` ``` | |
-| Code snippets | ` ```cpp`<br>text<br>` ``` ` | |
-| Console commands, output| ` ```sh`<br>text<br>` ``` ` | |
-| Product name | OpenVINO™,<br>Intel® Distribution of OpenVINO™ toolkit | |
-
-### Headings
-Use headings to section and organize your content for better readability and clarity.
-
-* **Use strong verbs.** Strong, active verbs get to the point. Avoid **-ing** verbs, such as Running, Testing, etc.
-* **Be concise and descriptive.** Use only the words necessary to describe the section.
-* **Use sentence case.** Capitalize first letter every word except articles, prepositions: **Build Inference Engine on Linux**
-* **Avoid punctuation.** Unless your heading is a question, don’t use sentence punctuation in headings.
-* **Use parallel structure.** Headings at the same level should use the same grammatical pattern. This provides structure to the document and helps users find information more easily. See [Parallelism](#parallelism).
-
-Use following rules to write headings in your documentation:
-* All files must have a top level heading, which is the title for the page.
- ```
- # First Level Heading
- ```
-* Up to three additional levels of headings are allowed under the title heading.
- ```
- ## Second Level Heading
- ### Third Level Heading
- #### Fourth Level Heading
- ```
-* Each heading should be followed by at least one paragraph of content. Avoid two or more consecutive headings.
-* To add a link to a heading in the current page, do the following:
- * Add the `<a>` HTML tag and set a unique name to your heading with `name` argument:
- ```XML
- ## <a name="set-the-environment-variables"></a> Set the Environment Variables
- ```
- * Place the link to the heading using the set name:
- ```XML
- Refer <a href="#set-the-environment-variables">here</a>
- ```
-
-### Code Snippets and Examples
-You can create fenced code snippets by placing triple backticks ` ``` ` before and after the code block and add an optional language identifier to enable syntax highlighting in your fenced code block. For example, to syntax highlight C++ code:
-```
-```cpp
-#include <inference_engine.hpp>
-void main(int argc, char *argv[])
-{
- InferenceEngine::Core ie;
-}
-```
-
-```cpp
-#include <inference_engine.hpp>
-void main(int argc, char *argv[])
-{
- InferenceEngine::Core ie;
-}
-```
-
-For full list with supported languages refer [here](https://github.com/github/linguist/blob/master/lib/linguist/languages.yml).
-
-### Lists and Instructions
-This section provides information about formatting numbered and bulleted lists.
-
-#### Numbered Lists
-Use a numbered list when the order or priority of the items is important, such as step-by-step instructions:
-```
-1. **Initialize core** to..
-2. **Prepare input** for..
-3. ...
-```
-Numbered lists are most frequently used for procedures. Use numbered lists to show sequence for the items. Follow our guidelines for numbered lists:
-* Make few first words describe whole step and bold it:
- 6) **Prepare input**. You can use one of the following options to prepare input
-* Introduce a numbered list with a sentence. End the setup text with a colon. Example:
- "To configure the unit, perform the following steps:"
-* Each item in the list should be [parallel](#parallelism).
-* Treat numbered list items as full sentences with correct ending punctuation.
-* You may interrupt numbered lists with other content, if relevant, e.g. explanatory text, commands, or code.
-
-#### Bulleted lists
-Use a bulleted list when the order of the items is not important:
-```
-* Option X
-* Option Y
-* Option Z
-```
-* Introduce a bulleted list with a sentence. End the setup text with a colon. Example:
- “To repair the unit, you will need the following items:”
-* Make few first words describe whole step and bold it:
- * **Prepare input**. You can use one of the following options to prepare input
-* Each item in the list should be parallel.
-* Avoid interrupting bulleted lists with other paragraph styles.
-* Second-level bullets are acceptable; avoid third-level bullets.
-
-For both list types, keep all items in the list parallel. See [Parallelism](#parallelism):
-
-### Links
-All links in content should follow these guidelines:
-
-* **Avoid generic text:** Don’t use generic, uninformative link text such as “click here” or “read more”.
-* **Write descriptive link text:** Link text should describe where the link goes, without having to read the surrounding text.
-* **Use unique link text:** Each link text on a page should be unique. If users see the same link text twice on a page, they’ll assume it goes to the same place.
-* **Start link text with keywords:** Frontload the link text with the most important words to help users scan the text.
-
-Use following examples to write links in your documentation:
-* To add a cross-reference to another documentation page, use file path from [DoxygenLayout.xml](./openvino-documentation/blob/master/docs/doxygen/DoxygenLayout.xml) (don't use direct links to docs.openvinotoolkit.org):
-```
-[OpenVINO Installation on Linux](./docs/install_guides/installing-openvino-linux.md)
-```
-Currently links to headings in other markdown files are not supported. To refer to a specific section, you may use the following example:
-```
-"Use **Set Environment Variables** section in the [OpenVINO Installation on Linux](./docs/install_guides/installing-openvino-linux.md) document.
-```
-* To add URL link to any software, link to the latest version, for example:
-```
-For more details, see [CMake page](https://cmake.org/cmake/help/latest/manual/cmake.1.html#manual:cmake(1))
-```
-
-## Graphics Guidelines
-Use images or figures to convey information that may be difficult to explain using words alone. Well-planned graphics reduce the amount of text required to explain a topic or example.
-
-Follow these guidelines when using graphics in support of your documentation:
-
-* Keep it simple. Use images that serve a specific purpose in your document, and contain only the information the reader needs.
-* Avoid graphics that will need frequent updating. Don’t include information in a graphic that might change with each release, such as product versions.
-* Use either PNG or JPEG bitmap files for screenshots and SVG files for vector graphics.
-* Place the image immediately after the text it helps clarify, or as close as possible.
-* Use the Markdown directives to insert images and figures into the document. Include both alt text, and the title.
-* Include at least one direct reference to an image from the main text, using the figure number.
-
-Images should follow these naming and location conventions:
-
-* Save the image files in a figures folder at the same level as the file that will reference the image.
-* Name image files according to the following rules:
- * Use only lower case letters.
- * Separate multiple words in filenames using dashes.
- * Name images using the filename of the file they appear on and add a number to indicate their place in the file. For example, the third figure added to the `welcome.md` file must be named `welcome-3.png`.
+++ /dev/null
-# Inference Engine hetero plugin design overview {#openvino_docs_hetero_plugin}
-
-## Subgraphs selection
-
-Algorithm:
-
-For each plugin
-1. Select *root* node
- * Node not in subgraph previously constructed
- * Affinity is equal to plugin name
-2. Select adjacent node to any node in already subgraph which is not in rejected list
- * if there are no such nodes **end**
-3. Check selected node has same affinity
-4. Add node to subgraph if check was successful or add to rejected list otherwise
-5. Check global condition
- * Nodes in rejected list can never be added to subgraph
- * Nodes not in subgraph and not in rejected list can possibly be added later
- * Check subgraph topology (the only check now is there are no indirect subgraph self-references)
-6. If global condition was failed remove last node from subgraph, add it to rejected list and go to step 5
- * we can rollback multiple times here because rejected list is changed every time
-7. Go to step 2
-
-Example:
-```
- 1
- |
- 2
- / \
- 3 4
- \ /
- 5
- |
- 6
- |
- 7
-```
-
-Nodes [1,2,3,5,6,7] are supported in plugin, [4] is not
-
-Possible roots: [1,2,3,5,6,7]
-1. Select root [1]
- * Subgraph: [1]
- * Rejected: []
- * Global condition: ok
-2. Merge [2]
- * Subgraph: [1,2]
- * Rejected: []
- * Global condition: ok
-3. Merge [3]
- * Subgraph: [1,2,3]
- * Rejected: []
- * Global condition: ok
-4. Merge [5]
- * Subgraph: [1,2,3,5]
- * Rejected: []
- * Global condition: There is possible self-references through node [4] but we do not know yet, ok
-5. Merge [6]
- * Subgraph: [1,2,3,5,6]
- * Rejected: []
- * Global condition: There is possible self-references through node [4] but we do not know yet, ok
-6. Merge [7]
- * Subgraph: [1,2,3,5,6,7]
- * Rejected: []
- * Global condition: There is possible self-references through node [4] but we do not know yet, ok
-7. Failed to merge [4]
- * Subgraph: [1,2,3,5,6,7]
- * Rejected: [4]
- * Global condition: There is self-references through node [4], reject
-8. Rollback [7]
- * Subgraph: [1,2,3,5,6]
- * Rejected: [4,7]
- * Global condition: There is self-references through node [4], reject
-9. Rollback [6]
- * Subgraph: [1,2,3,5]
- * Rejected: [4,6,7]
- * Global condition: There is self-references through node [4], reject
-10. Rollback [5]
- * Subgraph: [1,2,3]
- * Rejected: [4,5,6,7]
- * Global condition: ok
-11. There are nodes to merge **end**
-
-Possible roots: [5,6,7]
-1. Select root [5]
- * Subgraph: [5]
- * Rejected: []
- * Global condition: ok
-2. Merge [6]
- * Subgraph: [5,6]
- * Rejected: []
- * Global condition: ok
-3. Merge [7]
- * Subgraph: [5,6,7]
- * Rejected: []
- * Global condition: ok
-4. Merge [3]
- * Subgraph: [3,5,6,7]
- * Rejected: []
- * Global condition: ok
-5. Merge [2]
- * Subgraph: [2,3,5,6,7]
- * Rejected: []
- * Global condition: There is possible self-references through node [4] but we do not know yet, ok
-6. Failed to merge [4]
- * Subgraph: [2,3,5,6,7]
- * Rejected: [4]
- * Global condition: There is self-references through node [4], reject
-7. Rollback [2]
- * Subgraph: [3,5,6,7]
- * Rejected: [2,4]
- * Global condition: ok
-8. There are nodes to merge **end**
-
-Possible roots: [] no roots, **END**
-
-Subgraphs: [1,2,3], [3,5,6,7]
-
-Select best subgraph:
-* When we have multiple subgraphs larger ([3,5,6,7]) is always selected, always
-
-Repeat previous steps with remaining nodes [1,2]
-
-The final result is:
-* First plugin: [3,5,6,7], [1,2]
-* Second plugin: [4]
-
-
-## Subgraphs self reference detection
-
-1. For each node in network build a list of reachable node (transitive closure)
-2. For each pair of nodes in subgraph find `path` nodes (nodes through one node in pair reachable to other)
- * assume `src` - one node in pair, `dst` - other node in pair
- * get all nodes reachable from `src`
- * in those nodes find nodes through you can reach `dst` those will be our `path` node
-3. Results for pairs is cached.
-4. Check if there intersection between `path` nodes set and rejected nodes set for each nodes pair in subgraph
-5. In case of intersection we have a self-reference and subgraph is invalid
+++ /dev/null
-# Get Started with OpenVINO™ Toolkit on Linux*
-
-This guide provides you with the information that will help you to start using
-the OpenVINO™ Toolkit on Linux\*. With this guide, you will learn how to:
-
-1. [Configure the Model Optimizer](#configure-the-model-optimizer)
-2. [Prepare a model for sample inference](#prepare-a-model-for-sample-inference)
- 1. [Download a pre-trained model](#download-a-trained-model)
- 2. [Convert the model to an Intermediate Representation (IR) with the Model Optimizer](#convert-the-model-to-an-intermediate-representation-with-the-model-optimizer)
-3. [Run the Image Classification Sample Application with the model](#run-the-image-classification-sample-application)
-
-## Prerequisites
-1. This guide assumes that you have already cloned the `openvino` repo and
- successfully built the Inference Engine and Samples using the
- [build instructions](build-instruction.md).
-2. The original structure of the repository directories remains unchanged.
-
-> **NOTE**: Below, the directory to which the `openvino` repository is cloned is
-referred to as `<OPENVINO_DIR>`.
-
-## Configure the Model Optimizer
-
-The Model Optimizer is a Python\*-based command line tool for importing trained
-models from popular deep learning frameworks such as Caffe\*, TensorFlow\*,
-Apache MXNet\*, ONNX\* and Kaldi\*.
-
-You cannot perform inference on your trained model without having first run the
-model through the Model Optimizer. When you run a pre-trained model through the
-Model Optimizer, it outputs an *Intermediate Representation*, or *(IR)* of
-the network, a pair of files that describes the whole model:
-
-- `.xml`: Describes the network topology
-- `.bin`: Contains the weights and biases binary data
-
-For more information about the Model Optimizer, refer to the
-[Model Optimizer Developer Guide].
-
-### Model Optimizer Configuration Steps
-
-You can choose to either configure all supported frameworks at once **OR**
-configure one framework at a time. Choose the option that best suits your needs.
-If you see error messages, check for any missing dependencies.
-
-> **NOTE**: The TensorFlow\* framework is not officially supported on CentOS\*,
- so the Model Optimizer for TensorFlow cannot be configured on, or run with
- CentOS.
-
-> **IMPORTANT**: Internet access is required to execute the following steps
- successfully. If you access the Internet via proxy server only, please make
- sure that it is configured in your OS environment as well.
-
-**Option 1: Configure all supported frameworks at the same time**
-
-1. Go to the Model Optimizer prerequisites directory:
-```sh
-cd <OPENVINO_DIR>/model_optimizer/install_prerequisites
-```
-2. Run the script to configure the Model Optimizer for Caffe,
- TensorFlow 1.x, MXNet, Kaldi\*, and ONNX:
-```sh
-sudo ./install_prerequisites.sh
-```
-
-**Option 2: Configure each framework separately**
-
-Configure individual frameworks separately **ONLY** if you did not select
-**Option 1** above.
-
-1. Go to the Model Optimizer prerequisites directory:
-```sh
-cd <OPENVINO_DIR>/model_optimizer/install_prerequisites
-```
-2. Run the script for your model framework. You can run more than one script:
-
- - For **Caffe**:
- ```sh
- sudo ./install_prerequisites_caffe.sh
- ```
-
- - For **TensorFlow 1.x**:
- ```sh
- sudo ./install_prerequisites_tf.sh
- ```
-
- - For **TensorFlow 2.x**:
- ```sh
- sudo ./install_prerequisites_tf2.sh
- ```
-
- - For **MXNet**:
- ```sh
- sudo ./install_prerequisites_mxnet.sh
- ```
-
- - For **ONNX**:
- ```sh
- sudo ./install_prerequisites_onnx.sh
- ```
-
- - For **Kaldi**:
- ```sh
- sudo ./install_prerequisites_kaldi.sh
- ```
-The Model Optimizer is configured for one or more frameworks. Continue to the
-next session to download and prepare a model for running a sample inference.
-
-## Prepare a Model for Sample Inference
-
-This section describes how to get a pre-trained model for sample inference
-and how to prepare the optimized Intermediate Representation (IR) that
-Inference Inference Engine uses.
-
-
-### Download a Trained Model
-
-To run the Image Classification Sample, you need a pre-trained model to run
-the inference on. This guide uses the public SqueezeNet 1.1 Caffe\* model.
-You can find and download this model manually or use the OpenVINO™
-[Model Downloader].
-
-With the Model Downloader, you can download other popular public deep learning
-topologies and [OpenVINO™ pre-trained models], which are already prepared for
-running inference upon a wide list of inference scenarios:
-
-* object detection,
-* object recognition,
-* object re-identification,
-* human pose estimation,
-* action recognition, and others.
-
-To download the SqueezeNet 1.1 Caffe* model to a `models` folder (referred to
-as `<models_dir>` below) with the Model Downloader:
-
-1. Install the [prerequisites].
-2. Run the `downloader.py` script, specifying the topology name and the path
- to your `<models_dir>`. For example, to download the model to a directory
- named `~/public_models`, run:
- ```sh
- ./downloader.py --name squeezenet1.1 --output_dir ~/public_models
- ```
- When the model files are successfully downloaded, output similar to the
- following is printed:
- ```sh
- ################|| Downloading squeezenet1.1 ||################
-
- ========== Downloading /home/user/public_models/public/squeezenet1.1/squeezenet1.1.prototxt
- ... 100%, 9 KB, 19621 KB/s, 0 seconds passed
-
- ========== Downloading /home/user/public_models/public/squeezenet1.1/squeezenet1.1.caffemodel
- ... 100%, 4834 KB, 5159 KB/s, 0 seconds passed
-
- ========== Replacing text in /home/user/public_models/public/squeezenet1.1/squeezenet1.1.prototxt
- ```
-
-### Convert the model to an Intermediate Representation with the Model Optimizer
-
-> **NOTE**: This section assumes that you have configured the Model Optimizer using the instructions from the [Configure the Model Optimizer](#configure-the-model-optimizer) section.
-
-1. Create a `<ir_dir>` directory that will contains the Intermediate Representation (IR) of the model.
-
-2. Inference Engine can perform inference on a [list of supported devices]
- using specific device plugins. Different plugins support models of
- [different precision formats], such as `FP32`, `FP16`, `INT8`. To prepare an
- IR to run inference on particular hardware, run the Model Optimizer with the
- appropriate `--data_type` options:
-
- **For CPU (FP32):**
- ```sh
- python3 <OPENVINO_DIR>/model_optimizer/mo.py --input_model <models_dir>/public_models/public/squeezenet1.1/squeezenet1.1.caffemodel --data_type FP32 --output_dir <ir_dir>
- ```
-
- **For GPU and MYRIAD (FP16):**
- ```sh
- python3 <OPENVINO_DIR>/model_optimizer/mo.py --input_model <models_dir>/public_models/public/squeezenet1.1/squeezenet1.1.caffemodel --data_type FP16 --output_dir <ir_dir>
- ```
- After the Model Optimizer script is completed, the produced IR files (`squeezenet1.1.xml`, `squeezenet1.1.bin`) are in the specified `<ir_dir>` directory.
-
-3. Copy the `squeezenet1.1.labels` file from the `<OPENVINO_DIR>/scripts/demo/`
- folder to the model IR directory. This file contains the classes that ImageNet
- uses so that the inference results show text instead of classification numbers:
- ```sh
- cp <OPENVINO_DIR>/scripts/demo/squeezenet1.1.labels <ir_dir>
- ```
-
-Now you are ready to run the Image Classification Sample Application.
-
-## Run the Image Classification Sample Application
-
-The Inference Engine sample applications are automatically compiled when you
-built the Inference Engine using the [build instructions](build-instruction.md).
-The binary files are located in the `<OPENVINO_DIR>/bin/intel64/Release`
-directory.
-
-To run the Image Classification sample application with an input image on the prepared IR:
-
-1. Go to the samples build directory:
- ```sh
- cd <OPENVINO_DIR>/bin/intel64/Release
-
-2. Run the sample executable with specifying the `car.png` file from the
- `<OPENVINO_DIR>/scripts/demo/` directory as an input
- image, the IR of your model and a plugin for a hardware device to perform
- inference on:
-
- **For CPU:**
- ```sh
- ./classification_sample_async -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d CPU
- ```
-
- **For GPU:**
- ```sh
- ./classification_sample_async -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d GPU
- ```
-
- **For MYRIAD:**
-
- >**NOTE**: Running inference on VPU devices (Intel® Movidius™ Neural Compute
- Stick or Intel® Neural Compute Stick 2) with the MYRIAD plugin requires
- performing [additional hardware configuration steps](build-instruction.md#optional-additional-installation-steps-for-the-intel-neural-compute-stick-2).
- ```sh
- ./classification_sample_async -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d MYRIAD
- ```
-
-When the Sample Application completes, you will have the label and confidence for the top-10 categories printed on the screen. Below is a sample output with inference results on CPU:
-```sh
-Top 10 results:
-
-Image ../../../scripts/demo/car.png
-
-classid probability label
-------- ----------- -----
-817 0.8363342 sports car, sport car
-511 0.0946487 convertible
-479 0.0419130 car wheel
-751 0.0091071 racer, race car, racing car
-436 0.0068161 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
-656 0.0037564 minivan
-586 0.0025741 half track
-717 0.0016069 pickup, pickup truck
-864 0.0012027 tow truck, tow car, wrecker
-581 0.0005882 grille, radiator grille
-
-[ INFO ] Execution successful
-
-[ INFO ] This sample is an API example, for any performance measurements please use the dedicated benchmark_app tool
-```
-
-## Additional Resources
-
-* [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
-* [Inference Engine build instructions](build-instruction.md)
-* [Introduction to Intel® Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
-* [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
-* [Model Optimizer Developer Guide]
-* [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html).
-
-[Model Optimizer Developer Guide]:https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
-[Model Downloader]:https://github.com/opencv/open_model_zoo/tree/master/tools/downloader
-[OpenVINO™ pre-trained models]:https://github.com/opencv/open_model_zoo/tree/master/models/intel
-[prerequisites]:https://github.com/opencv/open_model_zoo/tree/master/tools/downloader#prerequisites
-[list of supported devices]:https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html
-[different precision formats]:https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html#supported_model_formats
projects / platform / upstream / dldt.git / commitdiff
